cc: Task should complete as finished or canceled in tests.

cc/raster/task_graph_runner_perftest.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
@@ skipping 58 matching lines @@
     // Avoid unnecessary heap allocations by reusing the same graph.
     TaskGraph graph;
 
     timer_.Reset();
     do {
       graph.Reset();
       BuildTaskGraph(top_level_tasks, tasks, leaf_tasks, &graph);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
+    CancelTasks(leaf_tasks);
+    CancelTasks(tasks);
+    CancelTasks(top_level_tasks);
+
     perf_test::PrintResult("build_task_graph",
                            TestModifierString(),
                            test_name,
                            timer_.LapsPerSecond(),
                            "runs/s",
                            true);
   }
 
   void RunScheduleTasksTest(const std::string& test_name,
                             int num_top_level_tasks,
@@ skipping 53 matching lines @@
     TaskGraph graph;
     Task::Vector completed_tasks;
 
     size_t count = 0;
     timer_.Reset();
     do {
       size_t current_version = count % kNumVersions;
       graph.Reset();
       // Reset tasks as we are not letting them execute, they get cancelled
       // when next ScheduleTasks() happens.
-      ResetTasks(&top_level_tasks[current_version]);
-      ResetTasks(&tasks[current_version]);
-      ResetTasks(&leaf_tasks[current_version]);
+      ResetTasks(top_level_tasks[current_version]);
+      ResetTasks(tasks[current_version]);
+      ResetTasks(leaf_tasks[current_version]);
       BuildTaskGraph(top_level_tasks[current_version], tasks[current_version],
                      leaf_tasks[current_version], &graph);
       task_graph_runner_->ScheduleTasks(namespace_token_, &graph);
       CollectCompletedTasks(&completed_tasks);
       completed_tasks.clear();
       ++count;
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     TaskGraph empty;
@@ skipping 20 matching lines @@
     CreateTasks(num_leaf_tasks, &leaf_tasks);
 
     // Avoid unnecessary heap allocations by reusing the same graph and
     // completed tasks vector.
     TaskGraph graph;
     Task::Vector completed_tasks;
 
     timer_.Reset();
     do {
       graph.Reset();
+      // Tasks run have finished state. Reset them to be considered as new for
+      // scheduling again.
+      ResetTasks(top_level_tasks);
+      ResetTasks(tasks);
+      ResetTasks(leaf_tasks);
       BuildTaskGraph(top_level_tasks, tasks, leaf_tasks, &graph);
       task_graph_runner_->ScheduleTasks(namespace_token_, &graph);
       task_graph_runner_->RunUntilIdle();
       CollectCompletedTasks(&completed_tasks);
       completed_tasks.clear();
-      ResetTasks(&top_level_tasks);
-      ResetTasks(&tasks);
-      ResetTasks(&leaf_tasks);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult("execute_tasks",
                            TestModifierString(),
                            test_name,
                            timer_.LapsPerSecond(),
                            "runs/s",
                            true);
   }
 
  private:
   static std::string TestModifierString() {
     return std::string("_task_graph_runner");
   }
 
   void CreateTasks(int num_tasks, PerfTaskImpl::Vector* tasks) {
     for (int i = 0; i < num_tasks; ++i)
       tasks->push_back(make_scoped_refptr(new PerfTaskImpl));
   }
 
-  void ResetTasks(PerfTaskImpl::Vector* tasks) {
-    for (PerfTaskImpl::Vector::iterator it = tasks->begin(); it != tasks->end();
-         ++it) {
-      PerfTaskImpl* task = it->get();
+  void CancelTasks(const PerfTaskImpl::Vector& tasks) {
+    for (auto& task : tasks)
+      task->state().DidCancel();
+  }
+
+  void ResetTasks(const PerfTaskImpl::Vector& tasks) {
+    for (auto& task : tasks)
       task->Reset();
-    }
   }
 
   void BuildTaskGraph(const PerfTaskImpl::Vector& top_level_tasks,
                       const PerfTaskImpl::Vector& tasks,
                       const PerfTaskImpl::Vector& leaf_tasks,
                       TaskGraph* graph) {
     DCHECK(graph->nodes.empty());
     DCHECK(graph->edges.empty());
 
     for (PerfTaskImpl::Vector::const_iterator it = leaf_tasks.begin();
@@ skipping 25 matching lines @@
          it != top_level_tasks.end(); ++it) {
       graph->nodes.push_back(TaskGraph::Node(
           it->get(), 0u, 0u, static_cast<uint32_t>(tasks.size())));
     }
   }
 
   size_t CollectCompletedTasks(Task::Vector* completed_tasks) {
     DCHECK(completed_tasks->empty());
     task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                               completed_tasks);
-    for (auto& task : *completed_tasks) {
-      // Reset task state as same task would be reused as if new.
-      task->state().Reset();
-    }
-
     return completed_tasks->size();
   }
 
   // Test uses SynchronousTaskGraphRunner, as this implementation introduces
   // minimal additional complexity over the TaskGraphWorkQueue helpers.
   std::unique_ptr<SynchronousTaskGraphRunner> task_graph_runner_;
   NamespaceToken namespace_token_;
   LapTimer timer_;
 };
 
@@ skipping 28 matching lines @@
   RunScheduleAndExecuteTasksTest("0_1_0", 0, 1, 0);
   RunScheduleAndExecuteTasksTest("0_32_0", 0, 32, 0);
   RunScheduleAndExecuteTasksTest("2_1_0", 2, 1, 0);
   RunScheduleAndExecuteTasksTest("2_32_0", 2, 32, 0);
   RunScheduleAndExecuteTasksTest("2_1_1", 2, 1, 1);
   RunScheduleAndExecuteTasksTest("2_32_1", 2, 32, 1);
 }
 
 }  // namespace
 }  // namespace cc