cc: Generalize raster task notifications

cc/resources/rasterizer.cc

 // Copyright 2014 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.
 
 #include "cc/resources/rasterizer.h"
 
 #include <algorithm>
 
 namespace cc {
 
@@ skipping 38 matching lines @@
 RasterTask::RasterTask(const Resource* resource,
                        ImageDecodeTask::Vector* dependencies)
     : resource_(resource) {
   dependencies_.swap(*dependencies);
 }
 
 RasterTask::~RasterTask() {}
 
 RasterTask* RasterTask::AsRasterTask() { return this; }
 
-RasterTaskQueue::Item::Item(RasterTask* task, bool required_for_activation)
-    : task(task), required_for_activation(required_for_activation) {}
+RasterTaskQueue::TaskSetSizes::TaskSetSizes() {
+  for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++)
+    sizes_[task_set] = 0;
+}
+
+RasterTaskQueue::Item::TaskSetCollection
+RasterTaskQueue::TaskSetSizes::ToTaskSetCollection() const {
+  Item::TaskSetCollection task_set_collection;
+  for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++) {
+    if (sizes_[task_set] > 0)
+      task_set_collection[task_set] = true;
+  }
+  return task_set_collection;
+}
+
+size_t& RasterTaskQueue::TaskSetSizes::operator[](TaskSet task_set) {
+  return sizes_[task_set];
+}
+
+const size_t& RasterTaskQueue::TaskSetSizes::operator[](
+    TaskSet task_set) const {
+  return sizes_[task_set];
+}
+
+bool RasterTaskQueue::TaskSetSizes::operator==(
+    const TaskSetSizes& other) const {
+  for (size_t i = 0; i < kMaxTaskSet; i++) {
+    if (sizes_[i] != other.sizes_[i])
+      return false;
+  }
+  return true;
+}
+
+void RasterTaskQueue::TaskSetSizes::operator+=(
+    const Item::TaskSetCollection& task_set_collection) {
+  for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++) {
+    if (task_set_collection[task_set])
+      sizes_[task_set]++;
+  }
+}
+
+void RasterTaskQueue::TaskSetSizes::operator-=(
+    const Item::TaskSetCollection& task_set_collection) {
+  for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++) {
+    if (task_set_collection[task_set])
+      sizes_[task_set]--;
+  }
+}
+
+RasterTaskQueue::Item::Item(RasterTask* task,
+                            const Item::TaskSetCollection& task_sets)
+    : task(task), task_sets(task_sets) {
+}
 
 RasterTaskQueue::Item::~Item() {}
 
-RasterTaskQueue::RasterTaskQueue() : required_for_activation_count(0u) {}
+RasterTaskQueue::RasterTaskQueue() {
+}
 
 RasterTaskQueue::~RasterTaskQueue() {}
 
+bool RasterTaskQueue::VerifyTaskSetSizes() const {
+  TaskSetSizes actual_task_set_sizes;
+  Item::Vector::const_iterator it = items.begin();
+  while (it != items.end()) {
+    actual_task_set_sizes += it->task_sets;
+    ++it;
+  }
+  return actual_task_set_sizes == task_set_sizes;
+}
+
 void RasterTaskQueue::Swap(RasterTaskQueue* other) {
   items.swap(other->items);
-  std::swap(required_for_activation_count,
-            other->required_for_activation_count);
+  std::swap(task_set_sizes, other->task_set_sizes);
 }
 
 void RasterTaskQueue::Reset() {
-  required_for_activation_count = 0u;
   items.clear();
+  task_set_sizes = TaskSetSizes();
 }
 
 }  // namespace cc