cc: Simplify task and its derived classes.

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 47 matching lines @@
 NamespaceToken TaskGraphWorkQueue::GetNamespaceToken() {
   NamespaceToken token(next_namespace_id_++);
   DCHECK(namespaces_.find(token) == namespaces_.end());
   return token;
 }
 
 void TaskGraphWorkQueue::ScheduleTasks(NamespaceToken token, TaskGraph* graph) {
   TaskNamespace& task_namespace = namespaces_[token];
 
   // First adjust number of dependencies to reflect completed tasks.
-  for (const scoped_refptr<Task>& task : task_namespace.completed_tasks) {
+  for (const scoped_refptr<DependencyTask>& task :
+       task_namespace.completed_tasks) {
     for (DependentIterator node_it(graph, task.get()); node_it; ++node_it) {
       TaskGraph::Node& node = *node_it;
       DCHECK_LT(0u, node.dependencies);
       node.dependencies--;
     }
   }
 
   // Build new "ready to run" queue and remove nodes from old graph.
   for (auto& ready_to_run_tasks_it : task_namespace.ready_to_run_tasks) {
     ready_to_run_tasks_it.second.clear();
@@ skipping 124 matching lines @@
 
   // Add task to |running_tasks|.
   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);
+  scoped_refptr<DependencyTask> task(completed_task.task);
 
   // Remove task from |running_tasks|.
   auto it = std::find_if(task_namespace->running_tasks.begin(),
                          task_namespace->running_tasks.end(),
                          [&completed_task](const CategorizedTask& task) {
                            return task.second == completed_task.task;
                          });
   DCHECK(it != task_namespace->running_tasks.end());
   std::swap(*it, task_namespace->running_tasks.back());
   task_namespace->running_tasks.pop_back();
@@ skipping 42 matching lines @@
       std::make_heap(ready_to_run_namespaces.begin(),
                      ready_to_run_namespaces.end(),
                      CompareTaskNamespacePriority(category));
     }
   }
 
   // Finally add task to |completed_tasks_|.
   task_namespace->completed_tasks.push_back(task);
 }
 
-void TaskGraphWorkQueue::CollectCompletedTasks(NamespaceToken token,
-                                               Task::Vector* completed_tasks) {
+void TaskGraphWorkQueue::CollectCompletedTasks(
+    NamespaceToken token,
+    DependencyTask::Vector* completed_tasks) {
   TaskNamespaceMap::iterator it = namespaces_.find(token);
   if (it == namespaces_.end())
     return;
 
   TaskNamespace& task_namespace = it->second;
 
   DCHECK_EQ(0u, completed_tasks->size());
   completed_tasks->swap(task_namespace.completed_tasks);
   if (!HasFinishedRunningTasksInNamespace(&task_namespace))
     return;
 
   // Remove namespace if finished running tasks.
   DCHECK_EQ(0u, task_namespace.completed_tasks.size());
   DCHECK(!HasReadyToRunTasksInNamespace(&task_namespace));
   DCHECK_EQ(0u, task_namespace.running_tasks.size());
   namespaces_.erase(it);
 }
 
 bool TaskGraphWorkQueue::DependencyMismatch(const TaskGraph* graph) {
   // Value storage will be 0-initialized.
-  std::unordered_map<const Task*, size_t> dependents;
+  std::unordered_map<const DependencyTask*, size_t> dependents;
   for (const TaskGraph::Edge& edge : graph->edges)
     dependents[edge.dependent]++;
 
   for (const TaskGraph::Node& node : graph->nodes) {
     if (dependents[node.task] != node.dependencies)
       return true;
   }
 
   return false;
 }
 
 }  // namespace cc