Move TaskGraph creation to TileManager

cc/raster/tile_task_worker_pool_perftest.cc

 // Copyright 2013 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/tile_task_worker_pool.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "cc/debug/lap_timer.h"
 #include "cc/output/context_provider.h"
@@ skipping 196 matching lines @@
           ScopedResource::Create(resource_provider_.get()));
       resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                          RGBA_8888);
 
       ImageDecodeTask::Vector dependencies = image_decode_tasks;
       raster_tasks->push_back(
           new PerfRasterTaskImpl(std::move(resource), &dependencies));
     }
   }
 
-  void BuildTileTaskQueue(TileTaskQueue* queue,
+  void BuildTileTaskGraph(TaskGraph* graph,
                           const RasterTaskVector& raster_tasks) {
-    for (size_t i = 0u; i < raster_tasks.size(); ++i) {
-      bool required_for_activation = (i % 2) == 0;
-      TaskSetCollection task_set_collection;
-      task_set_collection[ALL] = true;
-      task_set_collection[REQUIRED_FOR_ACTIVATION] = required_for_activation;
-      queue->items.push_back(
-          TileTaskQueue::Item(raster_tasks[i].get(), task_set_collection));
+    size_t priority = 0;
+
+    for (auto& raster_task : raster_tasks) {
+      priority++;
+
+      for (auto& decode_task : raster_task->dependencies()) {
+        graph->nodes.push_back(
+            TaskGraph::Node(decode_task.get(), priority, 0u));
+        graph->edges.push_back(
+            TaskGraph::Edge(raster_task.get(), decode_task.get()));
+      }
+
+      graph->nodes.push_back(TaskGraph::Node(
+          raster_task.get(), priority, raster_task->dependencies().size()));
     }
   }
 
  protected:
   scoped_refptr<ContextProvider> context_provider_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   scoped_ptr<SynchronousTaskGraphRunner> task_graph_runner_;
   LapTimer timer_;
 };
 
 class TileTaskWorkerPoolPerfTest
     : public TileTaskWorkerPoolPerfTestBase,
-      public testing::TestWithParam<TileTaskWorkerPoolType>,
-      public TileTaskRunnerClient {
+      public testing::TestWithParam<TileTaskWorkerPoolType> {
  public:
   // Overridden from testing::Test:
   void SetUp() override {
     switch (GetParam()) {
       case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY:
         Create3dOutputSurfaceAndResourceProvider();
         tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create(
             task_runner_.get(), task_graph_runner_.get(),
             resource_provider_.get(), false);
         break;
@@ skipping 13 matching lines @@
         break;
       case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
         CreateSoftwareOutputSurfaceAndResourceProvider();
         tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create(
             task_runner_.get(), task_graph_runner_.get(),
             resource_provider_.get());
         break;
     }
 
     DCHECK(tile_task_worker_pool_);
-    tile_task_worker_pool_->AsTileTaskRunner()->SetClient(this);
   }
   void TearDown() override {
     tile_task_worker_pool_->AsTileTaskRunner()->Shutdown();
     tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
   }
 
-  // Overriden from TileTaskRunnerClient:
-  void DidFinishRunningTileTasks(TaskSet task_set) override {
-    tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
-  }
-
   void RunMessageLoopUntilAllTasksHaveCompleted() {
     task_graph_runner_->RunUntilIdle();
     task_runner_->RunUntilIdle();
   }
 
   void RunScheduleTasksTest(const std::string& test_name,
                             unsigned num_raster_tasks,
                             unsigned num_image_decode_tasks) {
     ImageDecodeTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
 
-    // Avoid unnecessary heap allocations by reusing the same queue.
-    TileTaskQueue queue;
+    // Avoid unnecessary heap allocations by reusing the same graph.
+    TaskGraph graph;
 
     timer_.Reset();
     do {
-      queue.Reset();
-      BuildTileTaskQueue(&queue, raster_tasks);
-      tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue);
+      graph.Reset();
+      BuildTileTaskGraph(&graph, raster_tasks);
+      tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph);
       tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
-    TileTaskQueue empty;
+    TaskGraph empty;
     tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty);
     RunMessageLoopUntilAllTasksHaveCompleted();
 
     perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name,
                            timer_.LapsPerSecond(), "runs/s", true);
   }
 
   void RunScheduleAlternateTasksTest(const std::string& test_name,
                                      unsigned num_raster_tasks,
                                      unsigned num_image_decode_tasks) {
     const size_t kNumVersions = 2;
     ImageDecodeTask::Vector image_decode_tasks[kNumVersions];
     RasterTaskVector raster_tasks[kNumVersions];
     for (size_t i = 0; i < kNumVersions; ++i) {
       CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]);
       CreateRasterTasks(num_raster_tasks, image_decode_tasks[i],
                         &raster_tasks[i]);
     }
 
-    // Avoid unnecessary heap allocations by reusing the same queue.
-    TileTaskQueue queue;
+    // Avoid unnecessary heap allocations by reusing the same graph.
+    TaskGraph graph;
 
     size_t count = 0;
     timer_.Reset();
     do {
-      queue.Reset();
-      BuildTileTaskQueue(&queue, raster_tasks[count % kNumVersions]);
-      tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue);
+      graph.Reset();
+      BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]);
+      tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph);
       tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
       ++count;
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
-    TileTaskQueue empty;
+    TaskGraph empty;
     tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty);
     RunMessageLoopUntilAllTasksHaveCompleted();
 
     perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(),
                            test_name, timer_.LapsPerSecond(), "runs/s", true);
   }
 
   void RunScheduleAndExecuteTasksTest(const std::string& test_name,
                                       unsigned num_raster_tasks,
                                       unsigned num_image_decode_tasks) {
     ImageDecodeTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
 
-    // Avoid unnecessary heap allocations by reusing the same queue.
-    TileTaskQueue queue;
+    // Avoid unnecessary heap allocations by reusing the same graph.
+    TaskGraph graph;
 
     timer_.Reset();
     do {
-      queue.Reset();
-      BuildTileTaskQueue(&queue, raster_tasks);
-      tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue);
+      graph.Reset();
+      BuildTileTaskGraph(&graph, raster_tasks);
+      tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph);
       RunMessageLoopUntilAllTasksHaveCompleted();
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
-    TileTaskQueue empty;
+    TaskGraph empty;
     tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty);
     RunMessageLoopUntilAllTasksHaveCompleted();
 
     perf_test::PrintResult("schedule_and_execute_tasks", TestModifierString(),
                            test_name, timer_.LapsPerSecond(), "runs/s", true);
   }
 
  private:
   void Create3dOutputSurfaceAndResourceProvider() {
     output_surface_ = FakeOutputSurface::Create3d(context_provider_);
@@ skipping 68 matching lines @@
                                          public testing::Test {
  public:
   // Overridden from testing::Test:
   void SetUp() override {
     output_surface_ = FakeOutputSurface::Create3d(context_provider_);
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     resource_provider_ =
         FakeResourceProvider::Create(output_surface_.get(), nullptr);
   }
 
-  void RunBuildTileTaskQueueTest(const std::string& test_name,
+  void RunBuildTileTaskGraphTest(const std::string& test_name,
                                  unsigned num_raster_tasks,
                                  unsigned num_image_decode_tasks) {
     ImageDecodeTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
 
-    // Avoid unnecessary heap allocations by reusing the same queue.
-    TileTaskQueue queue;
+    // Avoid unnecessary heap allocations by reusing the same graph.
+    TaskGraph graph;
 
     timer_.Reset();
     do {
-      queue.Reset();
-      BuildTileTaskQueue(&queue, raster_tasks);
+      graph.Reset();
+      BuildTileTaskGraph(&graph, raster_tasks);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
-    perf_test::PrintResult("build_raster_task_queue", "", test_name,
+    perf_test::PrintResult("build_raster_task_graph", "", test_name,
                            timer_.LapsPerSecond(), "runs/s", true);
   }
 };
 
-TEST_F(TileTaskWorkerPoolCommonPerfTest, BuildTileTaskQueue) {
-  RunBuildTileTaskQueueTest("1_0", 1, 0);
-  RunBuildTileTaskQueueTest("32_0", 32, 0);
-  RunBuildTileTaskQueueTest("1_1", 1, 1);
-  RunBuildTileTaskQueueTest("32_1", 32, 1);
-  RunBuildTileTaskQueueTest("1_4", 1, 4);
-  RunBuildTileTaskQueueTest("32_4", 32, 4);
+TEST_F(TileTaskWorkerPoolCommonPerfTest, BuildTileTaskGraph) {
+  RunBuildTileTaskGraphTest("1_0", 1, 0);
+  RunBuildTileTaskGraphTest("32_0", 32, 0);
+  RunBuildTileTaskGraphTest("1_1", 1, 1);
+  RunBuildTileTaskGraphTest("32_1", 32, 1);
+  RunBuildTileTaskGraphTest("1_4", 1, 4);
+  RunBuildTileTaskGraphTest("32_4", 32, 4);
 }
 
 }  // namespace
 }  // namespace cc