cc: Implement states for Task for stricter control.

cc/raster/task_graph_work_queue.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/raster/task_graph_work_queue.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 126 matching lines @@
     // Remove any old nodes that are associated with this task. The result is
     // that the old graph is left with all nodes not present in this graph,
     // which we use below to determine what tasks need to be canceled.
     TaskGraph::Node::Vector::iterator old_it = std::find_if(
         task_namespace.graph.nodes.begin(), task_namespace.graph.nodes.end(),
         [node](const TaskGraph::Node& other) {
           return node.task == other.task;
         });
     if (old_it != task_namespace.graph.nodes.end()) {
       std::swap(*old_it, task_namespace.graph.nodes.back());
+      // If old task is scheduled to run again and not yet started running,
+      // reset its state to initial state as it has to be inserted in new
+      // |ready_to_run_tasks|, where it gets scheduled.
+      if (node.task->state().IsScheduled())
+        node.task->state().Reset();
       task_namespace.graph.nodes.pop_back();
     }
 
     // Task is not ready to run if dependencies are not yet satisfied.
     if (node.dependencies)
       continue;
 
     // Skip if already finished running task.
-    if (node.task->HasFinishedRunning())
+    if (node.task->state().IsFinished())
       continue;
 
     // Skip if already running.
     if (std::any_of(task_namespace.running_tasks.begin(),
                     task_namespace.running_tasks.end(),
                     [&node](const CategorizedTask& task) {
                       return task.second == node.task;
                     }))
       continue;
 
+    node.task->state().DidSchedule();
     task_namespace.ready_to_run_tasks[node.category].push_back(PrioritizedTask(
         node.task, &task_namespace, node.category, node.priority));
   }
 
   // Rearrange the elements in each vector within |ready_to_run_tasks| in such a
   // way that they form a heap.
   for (auto& it : task_namespace.ready_to_run_tasks) {
     auto& ready_to_run_tasks = it.second;
     std::make_heap(ready_to_run_tasks.begin(), ready_to_run_tasks.end(),
                    CompareTaskPriority);
   }
 
   // Swap task graph.
   task_namespace.graph.Swap(graph);
 
   // Determine what tasks in old graph need to be canceled.
   for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
        it != graph->nodes.end(); ++it) {
     TaskGraph::Node& node = *it;
 
     // Skip if already finished running task.
-    if (node.task->HasFinishedRunning())
+    if (node.task->state().IsFinished())
       continue;
 
     // Skip if already running.
     if (std::any_of(task_namespace.running_tasks.begin(),
                     task_namespace.running_tasks.end(),
                     [&node](const CategorizedTask& task) {
                       return task.second == node.task;
                     }))
       continue;
 
     DCHECK(std::find(task_namespace.completed_tasks.begin(),
                      task_namespace.completed_tasks.end(),
                      node.task) == task_namespace.completed_tasks.end());
+    node.task->state().DidCancel();
     task_namespace.completed_tasks.push_back(node.task);
   }
 
   // Build new "ready to run" task namespaces queue.
   for (auto& ready_to_run_namespaces_it : ready_to_run_namespaces_) {
     ready_to_run_namespaces_it.second.clear();
   }
   for (auto& namespace_it : namespaces_) {
     auto& task_namespace = namespace_it.second;
     for (auto& ready_to_run_tasks_it : task_namespace.ready_to_run_tasks) {
@@ skipping 40 matching lines @@
   // Add task namespace back to |ready_to_run_namespaces| if not empty after
   // taking top priority task.
   if (!ready_to_run_tasks.empty()) {
     ready_to_run_namespaces.push_back(task_namespace);
     std::push_heap(ready_to_run_namespaces.begin(),
                    ready_to_run_namespaces.end(),
                    CompareTaskNamespacePriority(category));
   }
 
   // Add task to |running_tasks|.
+  task.task->state().DidStart();
   task_namespace->running_tasks.push_back(
       std::make_pair(task.category, task.task));
 
   return task;
 }
 
 void TaskGraphWorkQueue::CompleteTask(const PrioritizedTask& completed_task) {
   TaskNamespace* task_namespace = completed_task.task_namespace;
   scoped_refptr<Task> task(completed_task.task);
 
@@ skipping 14 matching lines @@
     TaskGraph::Node& dependent_node = *it;
 
     DCHECK_LT(0u, dependent_node.dependencies);
     dependent_node.dependencies--;
     // Task is ready if it has no dependencies. Add it to |ready_to_run_tasks_|.
     if (!dependent_node.dependencies) {
       PrioritizedTask::Vector& ready_to_run_tasks =
           task_namespace->ready_to_run_tasks[dependent_node.category];
 
       bool was_empty = ready_to_run_tasks.empty();
+      dependent_node.task->state().DidSchedule();
       ready_to_run_tasks.push_back(
           PrioritizedTask(dependent_node.task, task_namespace,
                           dependent_node.category, dependent_node.priority));
       std::push_heap(ready_to_run_tasks.begin(), ready_to_run_tasks.end(),
                      CompareTaskPriority);
 
       // Task namespace is ready if it has at least one ready to run task. Add
       // it to |ready_to_run_namespaces_| if it just become ready.
       if (was_empty) {
         TaskNamespace::Vector& ready_to_run_namespaces =
@@ skipping 14 matching lines @@
     for (auto& it : ready_to_run_namespaces_) {
       uint16_t category = it.first;
       auto& ready_to_run_namespaces = it.second;
       std::make_heap(ready_to_run_namespaces.begin(),
                      ready_to_run_namespaces.end(),
                      CompareTaskNamespacePriority(category));
     }
   }
 
   // Finally add task to |completed_tasks_|.
+  task->state().DidFinish();
   task_namespace->completed_tasks.push_back(task);
 }
 
 void TaskGraphWorkQueue::CollectCompletedTasks(NamespaceToken token,
                                                Task::Vector* completed_tasks) {
   TaskNamespaceMap::iterator it = namespaces_.find(token);
   if (it == namespaces_.end())
     return;
 
   TaskNamespace& task_namespace = it->second;
@@ skipping 18 matching lines @@
 
   for (const TaskGraph::Node& node : graph->nodes) {
     if (dependents[node.task] != node.dependencies)
       return true;
   }
 
   return false;
 }
 
 }  // namespace cc