TaskGraphRunner Group support

cc/test/task_graph_runner_test_template.h

 // Copyright 2015 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.
 
 #ifndef CC_TEST_TASK_GRAPH_RUNNER_TEST_TEMPLATE_H_
 #define CC_TEST_TASK_GRAPH_RUNNER_TEST_TEMPLATE_H_
 
 #include "cc/raster/task_graph_runner.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #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 {
 
 class TaskGraphRunnerTestBase {
  public:
   struct TaskInfo {
     TaskInfo(int namespace_index,
              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;
   };
 
   TaskGraphRunnerTestBase() {}
 
   void SetTaskGraphRunner(TaskGraphRunner* task_graph_runner);
   void ResetIds(int namespace_index);
   void RunAllTasks(int namespace_index);
   void RunTaskOnWorkerThread(int namespace_index, unsigned id);
   void OnTaskCompleted(int namespace_index, unsigned id);
@@ skipping 71 matching lines @@
 TYPED_TEST_CASE_P(TaskGraphRunnerTest);
 
 TYPED_TEST_P(TaskGraphRunnerTest, Basic) {
   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());
 
-    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) {
     this->RunAllTasks(i);
 
     EXPECT_EQ(1u, this->run_task_ids(i).size());
     EXPECT_EQ(1u, this->on_task_completed_ids(i).size());
   }
 
   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);
 
     EXPECT_EQ(3u, this->run_task_ids(i).size());
     EXPECT_EQ(2u, this->on_task_completed_ids(i).size());
   }
 
   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);
 
     EXPECT_EQ(6u, this->run_task_ids(i).size());
     EXPECT_EQ(3u, this->on_task_completed_ids(i).size());
   }
 }
 
 TYPED_TEST_P(TaskGraphRunnerTest, Dependencies) {
   const int kNamespaceCount = TaskGraphRunnerTestBase::kNamespaceCount;
   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) {
     this->RunAllTasks(i);
 
     // Check if task ran before dependent.
     ASSERT_EQ(2u, this->run_task_ids(i).size());
     EXPECT_EQ(0u, this->run_task_ids(i)[0]);
     EXPECT_EQ(1u, this->run_task_ids(i)[1]);
     ASSERT_EQ(1u, this->on_task_completed_ids(i).size());
     EXPECT_EQ(0u, this->on_task_completed_ids(i)[0]);
   }
 
   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) {
     this->RunAllTasks(i);
 
     // Task should only run once.
     ASSERT_EQ(5u, this->run_task_ids(i).size());
     EXPECT_EQ(2u, this->run_task_ids(i)[2]);
     EXPECT_EQ(3u, this->run_task_ids(i)[3]);
     EXPECT_EQ(3u, this->run_task_ids(i)[4]);
     ASSERT_EQ(2u, this->on_task_completed_ids(i).size());
     EXPECT_EQ(2u, this->on_task_completed_ids(i)[1]);
   }
 }
 
-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 =
     TaskGraphRunnerTest<TaskRunnerTestDelegate>;
 
 TYPED_TEST_CASE_P(SingleThreadTaskGraphRunnerTest);
 
 TYPED_TEST_P(SingleThreadTaskGraphRunnerTest, Priority) {
   const int kNamespaceCount = TaskGraphRunnerTestBase::kNamespaceCount;
   using TaskInfo = TaskGraphRunnerTestBase::TaskInfo;
 
   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)));
   }
 
   for (int i = 0; i < kNamespaceCount; ++i) {
     this->RunAllTasks(i);
 
     // Check if tasks ran in order of priority.
     ASSERT_EQ(4u, this->run_task_ids(i).size());
     EXPECT_EQ(1u, this->run_task_ids(i)[0]);
     EXPECT_EQ(3u, this->run_task_ids(i)[1]);
     EXPECT_EQ(0u, this->run_task_ids(i)[2]);
     EXPECT_EQ(2u, this->run_task_ids(i)[3]);
     ASSERT_EQ(2u, this->on_task_completed_ids(i).size());
     EXPECT_EQ(1u, this->on_task_completed_ids(i)[0]);
     EXPECT_EQ(0u, this->on_task_completed_ids(i)[1]);
   }
 }
 
 REGISTER_TYPED_TEST_CASE_P(SingleThreadTaskGraphRunnerTest, Priority);
 
 }  // namespace cc
 
 #endif  // CC_TEST_TASK_GRAPH_RUNNER_TEST_TEMPLATE_H_