cc: Simplify task and its derived classes.

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 <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "cc/base/completion_event.h"
 #include "cc/debug/lap_timer.h"
 #include "cc/raster/synchronous_task_graph_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
 
 namespace cc {
 namespace {
 
 static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
-class PerfTaskImpl : public Task {
+class PerfTaskImpl : public DependencyTask {
  public:
   typedef std::vector<scoped_refptr<PerfTaskImpl>> Vector;
 
   PerfTaskImpl() {}
 
-  // Overridden from Task:
+  // Overridden from DependencyTask:
+  void ScheduleOnOriginThread(DependencyTaskClient* client) override {}
+  void CompleteOnOriginThread(DependencyTaskClient* client) override {}
   void RunOnWorkerThread() override {}
 
   void Reset() { did_run_ = false; }
 
  private:
   ~PerfTaskImpl() override {}
 
   DISALLOW_COPY_AND_ASSIGN(PerfTaskImpl);
 };
 
@@ skipping 47 matching lines @@
     PerfTaskImpl::Vector top_level_tasks;
     PerfTaskImpl::Vector tasks;
     PerfTaskImpl::Vector leaf_tasks;
     CreateTasks(num_top_level_tasks, &top_level_tasks);
     CreateTasks(num_tasks, &tasks);
     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;
+    DependencyTask::Vector completed_tasks;
 
     timer_.Reset();
     do {
       graph.Reset();
       BuildTaskGraph(top_level_tasks, tasks, leaf_tasks, &graph);
       task_graph_runner_->ScheduleTasks(namespace_token_, &graph);
       // Shouldn't be any tasks to collect as we reschedule the same set
       // of tasks.
       DCHECK_EQ(0u, CollectCompletedTasks(&completed_tasks));
       timer_.NextLap();
@@ skipping 21 matching lines @@
     PerfTaskImpl::Vector leaf_tasks[kNumVersions];
     for (size_t i = 0; i < kNumVersions; ++i) {
       CreateTasks(num_top_level_tasks, &top_level_tasks[i]);
       CreateTasks(num_tasks, &tasks[i]);
       CreateTasks(num_leaf_tasks, &leaf_tasks[i]);
     }
 
     // Avoid unnecessary heap allocations by reusing the same graph and
     // completed tasks vector.
     TaskGraph graph;
-    Task::Vector completed_tasks;
+    DependencyTask::Vector completed_tasks;
 
     size_t count = 0;
     timer_.Reset();
     do {
       graph.Reset();
       BuildTaskGraph(top_level_tasks[count % kNumVersions],
                      tasks[count % kNumVersions],
                      leaf_tasks[count % kNumVersions],
                      &graph);
       task_graph_runner_->ScheduleTasks(namespace_token_, &graph);
@@ skipping 22 matching lines @@
     PerfTaskImpl::Vector top_level_tasks;
     PerfTaskImpl::Vector tasks;
     PerfTaskImpl::Vector leaf_tasks;
     CreateTasks(num_top_level_tasks, &top_level_tasks);
     CreateTasks(num_tasks, &tasks);
     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;
+    DependencyTask::Vector completed_tasks;
 
     timer_.Reset();
     do {
       graph.Reset();
       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);
@@ skipping 60 matching lines @@
       }
     }
 
     for (PerfTaskImpl::Vector::const_iterator it = top_level_tasks.begin();
          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) {
+  size_t CollectCompletedTasks(DependencyTask::Vector* completed_tasks) {
     DCHECK(completed_tasks->empty());
     task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                               completed_tasks);
     return completed_tasks->size();
   }
 
   // Test uses SynchronousTaskGraphRunner, as this implementation introduces
   // minimal additional complexity over the TaskGraphWorkQueue helpers.
   scoped_ptr<SynchronousTaskGraphRunner> task_graph_runner_;
   NamespaceToken namespace_token_;
@@ skipping 31 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