Move TaskGraph creation to TileManager

cc/raster/tile_task_worker_pool_unittest.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 <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/cancelable_callback.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/base/unique_notifier.h"
 #include "cc/raster/bitmap_tile_task_worker_pool.h"
 #include "cc/raster/gpu_rasterizer.h"
 #include "cc/raster/gpu_tile_task_worker_pool.h"
 #include "cc/raster/one_copy_tile_task_worker_pool.h"
 #include "cc/raster/raster_buffer.h"
+#include "cc/raster/synchronous_task_graph_runner.h"
 #include "cc/raster/tile_task_runner.h"
 #include "cc/raster/zero_copy_tile_task_worker_pool.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/test/fake_display_list_raster_source.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_resource_provider.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
-#include "cc/test/test_task_graph_runner.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 const size_t kMaxBytesPerCopyOperation = 1000U;
 const size_t kMaxStagingBuffers = 32U;
 
@@ skipping 67 matching lines @@
  protected:
   ~BlockingTestRasterTaskImpl() override {}
 
  private:
   base::Lock* lock_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl);
 };
 
 class TileTaskWorkerPoolTest
-    : public testing::TestWithParam<TileTaskWorkerPoolType>,
-      public TileTaskRunnerClient {
+    : public testing::TestWithParam<TileTaskWorkerPoolType> {
  public:
   struct RasterTaskResult {
     unsigned id;
     bool canceled;
   };
 
   typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector;
 
   enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL };
 
@@ skipping 32 matching lines @@
         break;
       case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
         CreateSoftwareOutputSurfaceAndResourceProvider();
         tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create(
             base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_,
             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();
   }
 
   void AllTileTasksFinished() {
     tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
-  // Overriden from TileTaskWorkerPoolClient:
-  void DidFinishRunningTileTasks(TaskSet task_set) override {
-    EXPECT_FALSE(completed_task_sets_[task_set]);
-    completed_task_sets_[task_set] = true;
-    if (task_set == ALL) {
-      EXPECT_TRUE((~completed_task_sets_).none());
-      all_tile_tasks_finished_.Schedule();
-    }
-  }
-
   void RunMessageLoopUntilAllTasksHaveCompleted() {
-    if (timeout_seconds_) {
-      timeout_.Reset(base::Bind(&TileTaskWorkerPoolTest::OnTimeout,
-                                base::Unretained(this)));
-      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-          FROM_HERE, timeout_.callback(),
-          base::TimeDelta::FromSeconds(timeout_seconds_));
-    }
-
-    base::MessageLoop::current()->Run();
-
-    timeout_.Cancel();
-
-    ASSERT_FALSE(timed_out_) << "Test timed out";
+    task_graph_runner_.RunUntilIdle();
+    tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
   }
 
   void ScheduleTasks() {
-    TileTaskQueue queue;
+    graph_.Reset();
+
+    size_t priority = 0;
 
     for (RasterTaskVector::const_iterator it = tasks_.begin();
          it != tasks_.end(); ++it) {
-      TaskSetCollection task_sets;
-      task_sets[REQUIRED_FOR_ACTIVATION] = true;
-      task_sets[REQUIRED_FOR_DRAW] = true;
-      task_sets[ALL] = true;
-      queue.items.push_back(TileTaskQueue::Item(it->get(), task_sets));
+      graph_.nodes.emplace_back(it->get(), priority++, 0 /* dependencies */);
     }
 
-    completed_task_sets_.reset();
-    tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue);
+    tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph_);
   }
 
   void AppendTask(unsigned id, const gfx::Size& size) {
     scoped_ptr<ScopedResource> resource(
         ScopedResource::Create(resource_provider_.get()));
     resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                        RGBA_8888);
     const Resource* const_resource = resource.get();
 
     ImageDecodeTask::Vector empty;
@@ skipping 72 matching lines @@
 
  protected:
   scoped_refptr<TestContextProvider> context_provider_;
   scoped_refptr<TestContextProvider> worker_context_provider_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
   TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
   TestSharedBitmapManager shared_bitmap_manager_;
-  TestTaskGraphRunner task_graph_runner_;
+  SynchronousTaskGraphRunner task_graph_runner_;
   base::CancelableClosure timeout_;
   UniqueNotifier all_tile_tasks_finished_;
   int timeout_seconds_;
   bool timed_out_;
   RasterTaskVector tasks_;
   std::vector<RasterTaskResult> completed_tasks_;
-  TaskSetCollection completed_task_sets_;
+  TaskGraph graph_;
 };
 
 TEST_P(TileTaskWorkerPoolTest, Basic) {
   AppendTask(0u);
   AppendTask(1u);
   ScheduleTasks();
 
   RunMessageLoopUntilAllTasksHaveCompleted();
 
   ASSERT_EQ(2u, completed_tasks().size());
@@ skipping 48 matching lines @@
   AppendTask(1u);
   ScheduleTasks();
 
   RunMessageLoopUntilAllTasksHaveCompleted();
 
   ASSERT_EQ(2u, completed_tasks().size());
   EXPECT_FALSE(completed_tasks()[0].canceled);
   EXPECT_FALSE(completed_tasks()[1].canceled);
 }
 
-TEST_P(TileTaskWorkerPoolTest, ScheduleEmptyStillTriggersCallback) {
-  // Don't append any tasks, just call ScheduleTasks.
-  ScheduleTasks();
-
-  EXPECT_FALSE(completed_task_sets_[REQUIRED_FOR_ACTIVATION]);
-  EXPECT_FALSE(completed_task_sets_[REQUIRED_FOR_DRAW]);
-  EXPECT_FALSE(completed_task_sets_[ALL]);
-
-  RunMessageLoopUntilAllTasksHaveCompleted();
-
-  EXPECT_TRUE(completed_task_sets_[REQUIRED_FOR_ACTIVATION]);
-  EXPECT_TRUE(completed_task_sets_[REQUIRED_FOR_DRAW]);
-  EXPECT_TRUE(completed_task_sets_[ALL]);
-}
-
 INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolTests,
                         TileTaskWorkerPoolTest,
                         ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY,
                                           TILE_TASK_WORKER_POOL_TYPE_ONE_COPY,
                                           TILE_TASK_WORKER_POOL_TYPE_GPU,
                                           TILE_TASK_WORKER_POOL_TYPE_BITMAP));
 
 }  // namespace
 }  // namespace cc