TaskGraphRunner Group support

cc/test/task_graph_runner_test_template.h

Index: cc/test/task_graph_runner_test_template.h
diff --git a/cc/test/task_graph_runner_test_template.h b/cc/test/task_graph_runner_test_template.h
index d3989b9cae0c7e9a087c26793e2d1a1de8d58350..65a12052024e35b034c19a8f58cbee089f68c364 100644
--- a/cc/test/task_graph_runner_test_template.h
+++ b/cc/test/task_graph_runner_test_template.h
@@ -13,6 +13,7 @@
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/simple_thread.h"
+#include "cc/raster/task_category.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
@@ -24,17 +25,20 @@ class TaskGraphRunnerTestBase {
              unsigned id,
              unsigned dependent_id,
              unsigned dependent_count,
+             unsigned category,
              unsigned priority)
         : namespace_index(namespace_index),
           id(id),
           dependent_id(dependent_id),
           dependent_count(dependent_count),
+          category(category),
           priority(priority) {}
 
     int namespace_index;
     unsigned id;
     unsigned dependent_id;
     unsigned dependent_count;
+    unsigned category;
     unsigned priority;
   };
 
@@ -126,8 +130,9 @@ TYPED_TEST_P(TaskGraphRunnerTest, Basic) {
     EXPECT_EQ(0u, this->run_task_ids(i).size());
     EXPECT_EQ(0u, this->on_task_completed_ids(i).size());
 
-    this->ScheduleTasks(i,
-                        std::vector<TaskInfo>(1, TaskInfo(i, 0u, 0u, 0u, 0u)));
+    this->ScheduleTasks(
+        i, std::vector<TaskInfo>(
+               1, TaskInfo(i, 0u, 0u, 0u, TASK_CATEGORY_HIGH_PRIORITY, 0u)));
   }
 
   for (int i = 0; i < kNamespaceCount; ++i) {
@@ -138,8 +143,9 @@ TYPED_TEST_P(TaskGraphRunnerTest, Basic) {
   }
 
   for (int i = 0; i < kNamespaceCount; ++i)
-    this->ScheduleTasks(i,
-                        std::vector<TaskInfo>(1, TaskInfo(i, 0u, 0u, 1u, 0u)));
+    this->ScheduleTasks(
+        i, std::vector<TaskInfo>(
+               1, TaskInfo(i, 0u, 0u, 1u, TASK_CATEGORY_HIGH_PRIORITY, 0u)));
 
   for (int i = 0; i < kNamespaceCount; ++i) {
     this->RunAllTasks(i);
@@ -149,8 +155,9 @@ TYPED_TEST_P(TaskGraphRunnerTest, Basic) {
   }
 
   for (int i = 0; i < kNamespaceCount; ++i)
-    this->ScheduleTasks(i,
-                        std::vector<TaskInfo>(1, TaskInfo(i, 0u, 0u, 2u, 0u)));
+    this->ScheduleTasks(
+        i, std::vector<TaskInfo>(
+               1, TaskInfo(i, 0u, 0u, 2u, TASK_CATEGORY_HIGH_PRIORITY, 0u)));
 
   for (int i = 0; i < kNamespaceCount; ++i) {
     this->RunAllTasks(i);
@@ -165,9 +172,10 @@ TYPED_TEST_P(TaskGraphRunnerTest, Dependencies) {
   using TaskInfo = TaskGraphRunnerTestBase::TaskInfo;
 
   for (int i = 0; i < kNamespaceCount; ++i) {
-    this->ScheduleTasks(i, std::vector<TaskInfo>(1, TaskInfo(i, 0u, 1u,
-                                                             1u,  // 1 dependent
-                                                             0u)));
+    this->ScheduleTasks(
+        i, std::vector<TaskInfo>(1, TaskInfo(i, 0u, 1u,
+                                             1u,  // 1 dependent
+                                             TASK_CATEGORY_HIGH_PRIORITY, 0u)));
   }
 
   for (int i = 0; i < kNamespaceCount; ++i) {
@@ -182,10 +190,10 @@ TYPED_TEST_P(TaskGraphRunnerTest, Dependencies) {
   }
 
   for (int i = 0; i < kNamespaceCount; ++i) {
-    this->ScheduleTasks(i,
-                        std::vector<TaskInfo>(1, TaskInfo(i, 2u, 3u,
-                                                          2u,  // 2 dependents
-                                                          0u)));
+    this->ScheduleTasks(
+        i, std::vector<TaskInfo>(1, TaskInfo(i, 2u, 3u,
+                                             2u,  // 2 dependents
+                                             TASK_CATEGORY_HIGH_PRIORITY, 0u)));
   }
 
   for (int i = 0; i < kNamespaceCount; ++i) {
@@ -201,7 +209,59 @@ TYPED_TEST_P(TaskGraphRunnerTest, Dependencies) {
   }
 }
 
-REGISTER_TYPED_TEST_CASE_P(TaskGraphRunnerTest, Basic, Dependencies);
+TYPED_TEST_P(TaskGraphRunnerTest, Categorys) {
+  const int kNamespaceCount = TaskGraphRunnerTestBase::kNamespaceCount;
+  using TaskInfo = TaskGraphRunnerTestBase::TaskInfo;
+
+  for (int i = 0; i < kNamespaceCount; ++i) {
+    EXPECT_EQ(0u, this->run_task_ids(i).size());
+    EXPECT_EQ(0u, this->on_task_completed_ids(i).size());
+    std::vector<TaskInfo> tasks;
+    for (unsigned j = 0; j < kNumTaskCategories; ++j) {
+      tasks.emplace_back(i, 0u, 0u, 0u, j, 0u);
+    }
+    this->ScheduleTasks(i, tasks);
+  }
+
+  for (int i = 0; i < kNamespaceCount; ++i) {
+    this->RunAllTasks(i);
+
+    EXPECT_EQ(kNumTaskCategories, this->run_task_ids(i).size());
+    EXPECT_EQ(kNumTaskCategories, this->on_task_completed_ids(i).size());
+  }
+
+  for (int i = 0; i < kNamespaceCount; ++i) {
+    std::vector<TaskInfo> tasks;
+    for (unsigned j = 0; j < kNumTaskCategories; ++j) {
+      tasks.emplace_back(i, 0u, 0u, 1u, j, 0u);
+    }
+    this->ScheduleTasks(i, tasks);
+  }
+
+  for (int i = 0; i < kNamespaceCount; ++i) {
+    this->RunAllTasks(i);
+
+    EXPECT_EQ(kNumTaskCategories * 3u, this->run_task_ids(i).size());
+    EXPECT_EQ(kNumTaskCategories * 2u, this->on_task_completed_ids(i).size());
+  }
+
+  for (int i = 0; i < kNamespaceCount; ++i) {
+    std::vector<TaskInfo> tasks;
+    for (unsigned j = 0; j < kNumTaskCategories; ++j) {
+      tasks.emplace_back(i, 0u, 0u, 2u, j, 0u);
+    }
+    this->ScheduleTasks(i, tasks);
+  }
+
+  for (int i = 0; i < kNamespaceCount; ++i) {
+    this->RunAllTasks(i);
+
+    EXPECT_EQ(kNumTaskCategories * 6u, this->run_task_ids(i).size());
+    EXPECT_EQ(kNumTaskCategories * 3u, this->on_task_completed_ids(i).size());
+  }
+}
+
+REGISTER_TYPED_TEST_CASE_P(TaskGraphRunnerTest, Basic, Dependencies, Categorys);
 
 template <typename TaskRunnerTestDelegate>
 using SingleThreadTaskGraphRunnerTest =
@@ -215,8 +275,8 @@ TYPED_TEST_P(SingleThreadTaskGraphRunnerTest, Priority) {
 
   for (int i = 0; i < kNamespaceCount; ++i) {
     TaskInfo tasks[] = {
-        TaskInfo(i, 0u, 2u, 1u, 1u),  // Priority 1
-        TaskInfo(i, 1u, 3u, 1u, 0u)   // Priority 0
+        TaskInfo(i, 0u, 2u, 1u, 0u, 1u),  // Priority 1
+        TaskInfo(i, 1u, 3u, 1u, 0u, 0u)   // Priority 0
     };
     this->ScheduleTasks(i,
                         std::vector<TaskInfo>(tasks, tasks + arraysize(tasks)));