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 9943b70ae677f2807a429b1b9294687a01facc73..35425f17125da0cea828c5e4d9805809ae1056c6 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 TaskSetCollection& task_sets)
+    : type(UNSCHEDULED), task(task), task_sets(task_sets) {
+}
+
 // static
 scoped_ptr<RasterWorkerPool> PixelBufferRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
@@ -53,15 +60,9 @@ 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,
@@ -77,7 +78,7 @@ PixelBufferRasterWorkerPool::~PixelBufferRasterWorkerPool() {
   DCHECK_EQ(0u, raster_tasks_with_pending_upload_.size());
   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_ == TaskSetSizes());
 }
 
 Rasterizer* PixelBufferRasterWorkerPool::AsRasterizer() { return this; }
@@ -117,13 +118,11 @@ void PixelBufferRasterWorkerPool::Shutdown() {
 void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleTasks");
 
-  if (!should_notify_client_if_no_tasks_are_pending_)
+  if (should_notify_client_if_no_tasks_are_pending_.none())
     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_are_pending_.set();
+  task_set_sizes_ = TaskSetSizes();
 
   // Update raster task state and remove items from old queue.
   for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
@@ -151,21 +150,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.
@@ -197,8 +194,8 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
       state.type = RasterTaskState::COMPLETED;
     }
 
-    // No longer required for activation.
-    state.required_for_activation = false;
+    // No longer in any task set.
+    state.task_sets.reset();
   }
 
   raster_tasks_.Swap(queue);
@@ -272,33 +269,17 @@ void PixelBufferRasterWorkerPool::ReleaseBufferForRaster(RasterTask* task) {
   resource_provider_->ReleasePixelRasterBuffer(task->resource()->id());
 }
 
-void PixelBufferRasterWorkerPool::OnRasterFinished() {
-  TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::OnRasterFinished");
-
-  // |should_notify_client_if_no_tasks_are_pending_| can be set to false as
-  // a result of a scheduled CheckForCompletedRasterTasks() call. No need to
-  // perform another check in that case as we've already notified the client.
-  if (!should_notify_client_if_no_tasks_are_pending_)
-    return;
-  raster_finished_task_pending_ = false;
-
-  // Call CheckForCompletedRasterTasks() when we've finished running all
-  // raster tasks needed since last time ScheduleTasks() was called.
-  // This reduces latency between the time when all tasks have finished
-  // running and the time when the client is notified.
-  CheckForCompletedRasterTasks();
-}
-
-void PixelBufferRasterWorkerPool::OnRasterRequiredForActivationFinished() {
-  TRACE_EVENT0(
-      "cc",
-      "PixelBufferRasterWorkerPool::OnRasterRequiredForActivationFinished");
+void PixelBufferRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
+  TRACE_EVENT1("cc",
+               "PixelBufferRasterWorkerPool::OnRasterFinished",
+               "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_)
+  // There's no need to call CheckForCompletedRasterTasks() if the client has
+  // already been notified.
+  if (!should_notify_client_if_no_tasks_are_pending_[task_set])
     return;
-  raster_required_for_activation_finished_task_pending_ = false;
+  raster_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
@@ -338,8 +319,10 @@ void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
   }
 
   DCHECK(client_);
+  TaskSetCollection task_sets_forced_to_complete =

[reveman, 2014/09/16 22:49:05]

I prefer "tasks_that_should_be_forced_to_complete" instead of using a new name
for this variable.

[ernstm, 2014/09/17 19:57:14]

Done.

+      client_->TasksThatShouldBeForcedToComplete();
   bool should_force_some_uploads_to_complete =
-      shutdown_ || client_->ShouldForceTasksRequiredForActivationToComplete();
+      shutdown_ || task_sets_forced_to_complete.any();
 
   if (should_force_some_uploads_to_complete) {
     RasterTask::Vector tasks_with_uploads_to_force;
@@ -355,7 +338,7 @@ void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
 
       // Force all uploads required for activation to complete.

[reveman, 2014/09/16 22:49:04]

please update this comment.

[ernstm, 2014/09/17 19:57:15]

Done.

       // 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);
@@ -408,10 +391,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()).none());
+    task_set_sizes_ -= state.task_sets;
   }
 }
 
@@ -422,27 +404,20 @@ void PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks() {
   // Since this function can be called directly, cancel any pending checks.
   check_for_completed_raster_task_notifier_.Cancel();
 
-  DCHECK(should_notify_client_if_no_tasks_are_pending_);
+  DCHECK(should_notify_client_if_no_tasks_are_pending_.any());
 
   CheckForCompletedRasterizerTasks();
   CheckForCompletedUploads();
   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());
-  bool will_notify_client_that_no_tasks_are_pending =
-      (should_notify_client_if_no_tasks_are_pending_ &&
-       !raster_required_for_activation_finished_task_pending_ &&
-       !raster_finished_task_pending_ && !HasPendingTasks());
+  TaskSetCollection will_notify_client_that_no_tasks_in_set_are_pending =

[reveman, 2014/09/16 22:49:05]

s/will_notify_client_that_no_tasks_in_set_are_pending/will_notify_client_that_no_tasks_are_pending/

[ernstm, 2014/09/17 19:57:14]

Done.

+      should_notify_client_if_no_tasks_are_pending_ &
+      ~raster_finished_tasks_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_are_pending_ &=
-      !will_notify_client_that_no_tasks_are_pending;
+      ~will_notify_client_that_no_tasks_in_set_are_pending;
 
   scheduled_raster_task_count_ = 0;
   if (PendingRasterTaskCount())
@@ -453,18 +428,18 @@ void PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks() {
 
   // Schedule another check for completed raster tasks while there are
   // pending raster tasks or pending uploads.
-  if (HasPendingTasks())
+  if (HasPendingTasks().any())
     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();
-  }
-  if (will_notify_client_that_no_tasks_are_pending) {
+  if (should_notify_client_if_no_tasks_are_pending_.none())
     TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
-    DCHECK(!HasPendingTasksRequiredForActivation());
-    client_->DidFinishRunningTasks();
+
+  // Generate client notifications.
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++) {

[reveman, 2014/09/16 22:49:04]

nit: ++task_set

+    if (will_notify_client_that_no_tasks_in_set_are_pending[task_set]) {
+      DCHECK(!HasPendingTasks()[task_set]);
+      client_->DidFinishRunningTasks(task_set);
+    }
   }
 }
 
@@ -472,15 +447,14 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleMoreTasks");
 
   RasterTaskVector tasks;
-  RasterTaskVector tasks_required_for_activation;
+  RasterTaskVector tasks_in_set[kNumberOfTaskSets];

[reveman, 2014/09/16 22:49:04]

Why is "RasterTaskVector tasks[kNumberOfTaskSets]" not enough?

[ernstm, 2014/09/17 19:57:14]

We can't make any assumptions about the task sets in the raster worker pools. In
particular, we don't know that a set for ALL tasks exists. Theoretically, there
might be tasks that are not in any task set, but we still need to schedule them.

[reveman, 2014/09/17 22:08:23]

I forgot to comment on this in my last review. I think we should assume that all
tasks belong to some set for now and DCHECK if that's not the case. We can
refactor this in the future if we actually have to support the case where a task
doesn't belong to any task set. For now, let's keep things as simple as
possible.

[ernstm, 2014/09/17 22:42:04]

Done.

 
   unsigned priority = kRasterTaskPriorityBase;
 
   graph_.Reset();
 
   size_t bytes_pending_upload = bytes_pending_upload_;
-  bool did_throttle_raster_tasks = false;
-  bool did_throttle_raster_tasks_required_for_activation = false;
+  TaskSetCollection did_throttle_raster_tasks_in_set;

[reveman, 2014/09/16 22:49:04]

"did_throttle_raster_tasks" instead of adding the "_in_set" prefix?

[ernstm, 2014/09/17 19:57:14]

Done.

 
   for (RasterTaskQueue::Item::Vector::const_iterator it =
            raster_tasks_.items.begin();
@@ -515,9 +489,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
     new_bytes_pending_upload += task->resource()->bytes();
     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;
     }
 
@@ -530,9 +502,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;
     }
 
@@ -547,78 +517,58 @@ 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 < kNumberOfTaskSets; 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 = CreateRasterFinishedTask(
-        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()));
+  scoped_refptr<RasterizerTask> new_raster_finished_tasks[kNumberOfTaskSets];
+  TaskSetSizes scheduled_task_set_sizes;
+
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++) {

[reveman, 2014/09/16 22:49:04]

nit: ++task_set

[ernstm, 2014/09/17 19:57:14]

Done.

+    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_are_pending_[task_set]) {
+      new_raster_finished_tasks[task_set] = CreateRasterFinishedTask(
+          task_runner_.get(),
+          base::Bind(&PixelBufferRasterWorkerPool::OnRasterFinished,
+                     raster_finished_weak_ptr_factory_.GetWeakPtr(),
+                     task_set));
+      raster_finished_tasks_pending_[task_set] = true;
+      InsertNodeForTask(&graph_,
+                        new_raster_finished_tasks[task_set].get(),
+                        kRasterFinishedTaskPriority,
+                        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_raster_finished_tasks[task_set].get()));
+      }
     }
   }
 
-  scoped_refptr<RasterizerTask> new_raster_finished_task;
-
   size_t scheduled_raster_task_count = tasks.container().size();
   DCHECK_LE(scheduled_raster_task_count, PendingRasterTaskCount());
-  // Schedule OnRasterTasksFinished call only when notification is pending
-  // and throttling is not preventing all pending tasks from being scheduled.
-  if (!did_throttle_raster_tasks &&
-      should_notify_client_if_no_tasks_are_pending_) {
-    new_raster_finished_task = CreateRasterFinishedTask(
-        task_runner_.get(),
-        base::Bind(&PixelBufferRasterWorkerPool::OnRasterFinished,
-                   raster_finished_weak_ptr_factory_.GetWeakPtr()));
-    raster_finished_task_pending_ = true;
-    InsertNodeForTask(&graph_,
-                      new_raster_finished_task.get(),
-                      kRasterFinishedTaskPriority,
-                      scheduled_raster_task_count);
-    for (RasterTaskVector::ContainerType::const_iterator it =
-             tasks.container().begin();
-         it != tasks.container().end();
-         ++it) {
-      graph_.edges.push_back(
-          TaskGraph::Edge(*it, new_raster_finished_task.get()));
-    }
-  }
 
   ScheduleTasksOnOriginThread(this, &graph_);
   task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
 
   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;
+  std::copy(new_raster_finished_tasks,
+            new_raster_finished_tasks + kNumberOfTaskSets,
+            raster_finished_tasks_);
 }
 
 unsigned PixelBufferRasterWorkerPool::PendingRasterTaskCount() const {
@@ -628,12 +578,8 @@ unsigned PixelBufferRasterWorkerPool::PendingRasterTaskCount() const {
   return raster_task_states_.size() - num_completed_raster_tasks;
 }
 
-bool PixelBufferRasterWorkerPool::HasPendingTasks() const {
-  return PendingRasterTaskCount() || !raster_tasks_with_pending_upload_.empty();
-}
-
-bool PixelBufferRasterWorkerPool::HasPendingTasksRequiredForActivation() const {
-  return !!raster_tasks_required_for_activation_count_;
+TaskSetCollection PixelBufferRasterWorkerPool::HasPendingTasks() const {
+  return task_set_sizes_.ToTaskSetCollection();
 }
 
 const char* PixelBufferRasterWorkerPool::StateName() const {
@@ -699,10 +645,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()).none());
+      task_set_sizes_ -= state.task_sets;
       continue;
     }
 
@@ -724,8 +669,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 < kNumberOfTaskSets; task_set++) {

[reveman, 2014/09/16 22:49:04]

nit: ++task_set

[ernstm, 2014/09/17 19:57:15]

Done.

+    state->SetInteger(
+        base::StringPrintf("pending_task_in_set_%u",
+                           static_cast<unsigned>(task_set)).c_str(),
+        task_set_sizes_[task_set]);

[reveman, 2014/09/16 22:49:04]

Use a "pending_count" array instead?

[ernstm, 2014/09/17 19:57:14]

Done.

+  }
   state->BeginDictionary("throttle_state");
   ThrottleStateAsValueInto(state.get());
   state->EndDictionary();
@@ -741,4 +690,54 @@ void PixelBufferRasterWorkerPool::ThrottleStateAsValueInto(
                              scheduled_raster_task_count_);
 }
 
+PixelBufferRasterWorkerPool::TaskSetSizes::TaskSetSizes() {
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++)

[reveman, 2014/09/16 22:49:04]

nit: ++task_set here and below

[ernstm, 2014/09/17 19:57:14]

Done.

+    sizes_[task_set] = 0;
+}
+
+TaskSetCollection
+PixelBufferRasterWorkerPool::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& PixelBufferRasterWorkerPool::TaskSetSizes::operator[](
+    TaskSet task_set) {
+  return sizes_[task_set];
+}
+
+const size_t& PixelBufferRasterWorkerPool::TaskSetSizes::operator[](
+    TaskSet task_set) const {
+  return sizes_[task_set];
+}
+
+bool PixelBufferRasterWorkerPool::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 PixelBufferRasterWorkerPool::TaskSetSizes::operator+=(
+    const TaskSetCollection& task_set_collection) {

[reveman, 2014/09/16 22:49:04]

nit: s/task_set_collection/task_sets/

[ernstm, 2014/09/17 19:57:14]

Done.

+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++) {
+    if (task_set_collection[task_set])
+      sizes_[task_set]++;
+  }
+}
+
+void PixelBufferRasterWorkerPool::TaskSetSizes::operator-=(
+    const TaskSetCollection& task_set_collection) {

[reveman, 2014/09/16 22:49:04]

nit: s/task_set_collection/task_sets/

[ernstm, 2014/09/17 19:57:15]

Done.

+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++) {
+    if (task_set_collection[task_set])
+      sizes_[task_set]--;
+  }
+}
+
 }  // namespace cc