cc: Simplify task and its derived classes.

cc/raster/task_graph_work_queue.h

 // 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.
 
 #ifndef CC_RASTER_TASK_GRAPH_WORK_QUEUE_H_
 #define CC_RASTER_TASK_GRAPH_WORK_QUEUE_H_
 
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 13 matching lines @@
 // be put into different categories, each of which is prioritized independently
 // from the others. It is up to the implementation of TaskGraphRunner to
 // define the meaning of the categories and handle them appropriately.
 class CC_EXPORT TaskGraphWorkQueue {
  public:
   struct TaskNamespace;
 
   struct PrioritizedTask {
     typedef std::vector<PrioritizedTask> Vector;
 
-    PrioritizedTask(Task* task,
+    PrioritizedTask(DependencyTask* task,
                     TaskNamespace* task_namespace,
                     uint16_t category,
                     uint16_t priority)
         : task(task),
           task_namespace(task_namespace),
           category(category),
           priority(priority) {}
 
-    Task* task;
+    DependencyTask* task;
     TaskNamespace* task_namespace;
     uint16_t category;
     uint16_t priority;
   };
 
-  using CategorizedTask = std::pair<uint16_t, scoped_refptr<Task>>;
+  using CategorizedTask = std::pair<uint16_t, scoped_refptr<DependencyTask>>;
 
   // Helper classes and static methods used by dependent classes.
   struct TaskNamespace {
     typedef std::vector<TaskNamespace*> Vector;
 
     TaskNamespace();
     TaskNamespace(const TaskNamespace& other);
     ~TaskNamespace();
 
     // Current task graph.
     TaskGraph graph;
 
     // Map from category to a vector of tasks that are ready to run for that
     // category.
     std::map<uint16_t, PrioritizedTask::Vector> ready_to_run_tasks;
 
     // Completed tasks not yet collected by origin thread.
-    Task::Vector completed_tasks;
+    DependencyTask::Vector completed_tasks;
 
     // This set contains all currently running tasks.
     std::vector<CategorizedTask> running_tasks;
   };
 
   TaskGraphWorkQueue();
   virtual ~TaskGraphWorkQueue();
 
   // Gets a NamespaceToken which is guaranteed to be unique within this
   // TaskGraphWorkQueue.
   NamespaceToken GetNamespaceToken();
 
   // Updates a TaskNamespace with a new TaskGraph to run. This cancels any
   // previous tasks in the graph being replaced.
   void ScheduleTasks(NamespaceToken token, TaskGraph* graph);
 
   // Returns the next task to run for the given category.
   PrioritizedTask GetNextTaskToRun(uint16_t category);
 
   // Marks a task as completed, adding it to its namespace's list of completed
   // tasks and updating the list of |ready_to_run_namespaces|.
   void CompleteTask(const PrioritizedTask& completed_task);
 
   // Helper which populates a vector of completed tasks from the provided
   // namespace.
   void CollectCompletedTasks(NamespaceToken token,
-                             Task::Vector* completed_tasks);
+                             DependencyTask::Vector* completed_tasks);
 
   // Helper which returns the raw TaskNamespace* for the given token. Used to
   // allow callers to re-use a TaskNamespace*, reducing the number of lookups
   // needed.
   TaskNamespace* GetNamespaceForToken(NamespaceToken token) {
     auto it = namespaces_.find(token);
     if (it == namespaces_.end())
       return nullptr;
     return &it->second;
   }
@@ skipping 78 matching lines @@
   // Map from category to a vector of ready to run namespaces for that category.
   std::map<uint16_t, TaskNamespace::Vector> ready_to_run_namespaces_;
 
   // Provides a unique id to each NamespaceToken.
   int next_namespace_id_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RASTER_TASK_GRAPH_WORK_QUEUE_H_