cc: Move GPU raster to DirectRasterWorkerPool.

cc/resources/raster_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/resources/raster_worker_pool.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/cancelable_callback.h"
+#include "cc/resources/direct_raster_worker_pool.h"
 #include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/picture_pile.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 enum RasterThread {
   RASTER_THREAD_NONE,
   RASTER_THREAD_ORIGIN,
   RASTER_THREAD_WORKER
 };
 
 enum RasterWorkerPoolType {
   RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
-  RASTER_WORKER_POOL_TYPE_IMAGE
+  RASTER_WORKER_POOL_TYPE_IMAGE,
+  RASTER_WORKER_POOL_TYPE_DIRECT
 };
 
 class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
  public:
   typedef base::Callback<void(const PicturePileImpl::Analysis& analysis,
                               bool was_canceled,
                               RasterThread raster_thread)> Reply;
 
   TestRasterWorkerPoolTaskImpl(const Resource* resource,
                                const Reply& reply,
-                               internal::Task::Vector* dependencies,
-                               bool use_gpu_rasterization)
-      : internal::RasterWorkerPoolTask(resource,
-                                       dependencies,
-                                       use_gpu_rasterization),
+                               internal::WorkerPoolTask::Vector* dependencies)
+      : internal::RasterWorkerPoolTask(resource, dependencies),
         reply_(reply),
         raster_thread_(RASTER_THREAD_NONE) {}
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
     raster_thread_ = RASTER_THREAD_WORKER;
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
     client->AcquireCanvasForRaster(this);
   }
+  virtual void RunOnOriginThread() OVERRIDE {
+    raster_thread_ = RASTER_THREAD_ORIGIN;
+  }
   virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
     client->OnRasterCompleted(this, PicturePileImpl::Analysis());
   }
   virtual void RunReplyOnOriginThread() OVERRIDE {
     reply_.Run(
         PicturePileImpl::Analysis(), !HasFinishedRunning(), raster_thread_);
   }
 
-  // Overridden from internal::RasterWorkerPoolTask:
-  virtual void RunOnOriginThread(ResourceProvider* resource_provider,
-                                 ContextProvider* context_provider) OVERRIDE {
-    raster_thread_ = RASTER_THREAD_ORIGIN;
-  }
-
  protected:
   virtual ~TestRasterWorkerPoolTaskImpl() {}
 
  private:
   const Reply reply_;
   RasterThread raster_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRasterWorkerPoolTaskImpl);
 };
 
 class BlockingTestRasterWorkerPoolTaskImpl
     : public TestRasterWorkerPoolTaskImpl {
  public:
-  BlockingTestRasterWorkerPoolTaskImpl(const Resource* resource,
-                                       const Reply& reply,
-                                       base::Lock* lock,
-                                       internal::Task::Vector* dependencies,
-                                       bool use_gpu_rasterization)
-      : TestRasterWorkerPoolTaskImpl(resource,
-                                     reply,
-                                     dependencies,
-                                     use_gpu_rasterization),
+  BlockingTestRasterWorkerPoolTaskImpl(
+      const Resource* resource,
+      const Reply& reply,
+      base::Lock* lock,
+      internal::WorkerPoolTask::Vector* dependencies)
+      : TestRasterWorkerPoolTaskImpl(resource, reply, dependencies),
         lock_(lock) {}
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
     base::AutoLock lock(*lock_);
     TestRasterWorkerPoolTaskImpl::RunOnWorkerThread(thread_index);
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void RunReplyOnOriginThread() OVERRIDE {}
 
  protected:
   virtual ~BlockingTestRasterWorkerPoolTaskImpl() {}
 
  private:
   base::Lock* lock_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterWorkerPoolTaskImpl);
 };
 
 class RasterWorkerPoolTest
     : public testing::TestWithParam<RasterWorkerPoolType>,
       public RasterWorkerPoolClient {
  public:
   class RasterTask : public RasterWorkerPool::RasterTask {
    public:
     typedef std::vector<RasterTask> Vector;
 
     static RasterTask Create(const Resource* resource,
-                             const TestRasterWorkerPoolTaskImpl::Reply& reply,
-                             bool use_gpu_rasterization) {
-      internal::Task::Vector dependencies;
-      return RasterTask(new TestRasterWorkerPoolTaskImpl(
-          resource, reply, &dependencies, use_gpu_rasterization));
+                             const TestRasterWorkerPoolTaskImpl::Reply& reply) {
+      internal::WorkerPoolTask::Vector dependencies;
+      return RasterTask(
+          new TestRasterWorkerPoolTaskImpl(resource, reply, &dependencies));
     }
 
     static RasterTask CreateBlocking(
         const Resource* resource,
         const TestRasterWorkerPoolTaskImpl::Reply& reply,
-        base::Lock* lock,
-        bool use_gpu_rasterization) {
-      internal::Task::Vector dependencies;
+        base::Lock* lock) {
+      internal::WorkerPoolTask::Vector dependencies;
       return RasterTask(new BlockingTestRasterWorkerPoolTaskImpl(
-          resource, reply, lock, &dependencies, use_gpu_rasterization));
+          resource, reply, lock, &dependencies));
     }
 
    private:
     friend class RasterWorkerPoolTest;
 
     explicit RasterTask(internal::RasterWorkerPoolTask* task)
         : RasterWorkerPool::RasterTask(task) {}
   };
 
   struct RasterTaskResult {
     unsigned id;
     bool canceled;
     RasterThread raster_thread;
   };
 
   RasterWorkerPoolTest()
       : context_provider_(TestContextProvider::Create()),
         timeout_seconds_(5),
         timed_out_(false) {
     output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     resource_provider_ = ResourceProvider::Create(
                              output_surface_.get(), NULL, 0, false, 1).Pass();
 
     switch (GetParam()) {
       case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
         raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
             resource_provider_.get(),
-            context_provider_.get(),
             std::numeric_limits<size_t>::max());
         break;
       case RASTER_WORKER_POOL_TYPE_IMAGE:
         raster_worker_pool_ = ImageRasterWorkerPool::Create(
-            resource_provider_.get(), context_provider_.get(), GL_TEXTURE_2D);
+            resource_provider_.get(), GL_TEXTURE_2D);
+        break;
+      case RASTER_WORKER_POOL_TYPE_DIRECT:
+        raster_worker_pool_ = DirectRasterWorkerPool::Create(
+            resource_provider_.get(), context_provider_.get());
         break;
     }
 
     DCHECK(raster_worker_pool_);
     raster_worker_pool_->SetClient(this);
   }
   virtual ~RasterWorkerPoolTest() { resource_provider_.reset(); }
 
   // Overridden from testing::Test:
   virtual void TearDown() OVERRIDE {
@@ skipping 23 matching lines @@
     }
 
     base::MessageLoop::current()->Run();
 
     timeout_.Cancel();
 
     ASSERT_FALSE(timed_out_) << "Test timed out";
   }
 
   void ScheduleTasks() {
-    RasterWorkerPool::RasterTask::Queue tasks;
+    RasterWorkerPool::RasterTask::Queue queue;
 
     for (RasterTask::Vector::iterator it = tasks_.begin(); it != tasks_.end();
          ++it)
-      tasks.Append(*it, false);
+      queue.Append(*it, false);
 
-    raster_worker_pool_->ScheduleTasks(&tasks);
+    raster_worker_pool_->ScheduleTasks(&queue);
   }
 
-  void AppendTask(unsigned id, bool use_gpu_rasterization) {
+  void AppendTask(unsigned id) {
     const gfx::Size size(1, 1);
 
     scoped_ptr<ScopedResource> resource(
         ScopedResource::Create(resource_provider_.get()));
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
     tasks_.push_back(
         RasterTask::Create(const_resource,
                            base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                                       base::Unretained(this),
                                       base::Passed(&resource),
-                                      id),
-                           use_gpu_rasterization));
+                                      id)));
   }
 
   void AppendBlockingTask(unsigned id, base::Lock* lock) {
     const gfx::Size size(1, 1);
 
     scoped_ptr<ScopedResource> resource(
         ScopedResource::Create(resource_provider_.get()));
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
     tasks_.push_back(RasterTask::CreateBlocking(
         const_resource,
         base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                    base::Unretained(this),
                    base::Passed(&resource),
                    id),
-        lock,
-        false));
+        lock));
   }
 
   const std::vector<RasterTaskResult>& completed_tasks() const {
     return completed_tasks_;
   }
 
  private:
   void OnTaskCompleted(scoped_ptr<ScopedResource> resource,
                        unsigned id,
                        const PicturePileImpl::Analysis& analysis,
@@ skipping 18 matching lines @@
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<RasterWorkerPool> raster_worker_pool_;
   base::CancelableClosure timeout_;
   int timeout_seconds_;
   bool timed_out_;
   std::vector<RasterTask> tasks_;
   std::vector<RasterTaskResult> completed_tasks_;
 };
 
 TEST_P(RasterWorkerPoolTest, Basic) {
-  AppendTask(0u, false);
-  AppendTask(1u, false);
+  AppendTask(0u);
+  AppendTask(1u);
   ScheduleTasks();
 
   RunMessageLoopUntilAllTasksHaveCompleted();
 
   ASSERT_EQ(2u, completed_tasks().size());
   EXPECT_FALSE(completed_tasks()[0].canceled);
   EXPECT_FALSE(completed_tasks()[1].canceled);
-  EXPECT_EQ(RASTER_THREAD_WORKER, completed_tasks()[0].raster_thread);
-  EXPECT_EQ(RASTER_THREAD_WORKER, completed_tasks()[1].raster_thread);
-}
-
-TEST_P(RasterWorkerPoolTest, GpuRaster) {
-  AppendTask(0u, true);  // GPU raster.
-  ScheduleTasks();
-
-  RunMessageLoopUntilAllTasksHaveCompleted();
-
-  ASSERT_EQ(1u, completed_tasks().size());
-  EXPECT_EQ(0u, completed_tasks()[0].id);
-  EXPECT_FALSE(completed_tasks()[0].canceled);
-  EXPECT_EQ(RASTER_THREAD_ORIGIN, completed_tasks()[0].raster_thread);
-}
-
-TEST_P(RasterWorkerPoolTest, HybridRaster) {
-  AppendTask(0u, false);  // Software raster.
-  AppendTask(1u, true);   // GPU raster.
-  ScheduleTasks();
-
-  RunMessageLoopUntilAllTasksHaveCompleted();
-
-  ASSERT_EQ(2u, completed_tasks().size());
-  for (int i = 0; i < 2; ++i) {
-    EXPECT_FALSE(completed_tasks()[i].canceled);
-    switch (completed_tasks()[i].id) {
-      case 0u:
-        EXPECT_EQ(RASTER_THREAD_WORKER, completed_tasks()[i].raster_thread);
-        break;
-      case 1u:
-        EXPECT_EQ(RASTER_THREAD_ORIGIN, completed_tasks()[i].raster_thread);
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
+  EXPECT_NE(RASTER_THREAD_NONE, completed_tasks()[0].raster_thread);
+  EXPECT_NE(RASTER_THREAD_NONE, completed_tasks()[1].raster_thread);
 }
 
 TEST_P(RasterWorkerPoolTest, FailedMapResource) {
   TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d();
   context3d->set_times_map_image_chromium_succeeds(0);
   context3d->set_times_map_buffer_chromium_succeeds(0);
-  AppendTask(0u, false);
+  AppendTask(0u);
   ScheduleTasks();
 
   RunMessageLoopUntilAllTasksHaveCompleted();
 
   ASSERT_EQ(1u, completed_tasks().size());
   EXPECT_FALSE(completed_tasks()[0].canceled);
-  EXPECT_EQ(RASTER_THREAD_WORKER, completed_tasks()[0].raster_thread);
+  EXPECT_NE(RASTER_THREAD_NONE, completed_tasks()[0].raster_thread);
 }
 
 // This test checks that replacing a pending raster task with another does
 // not prevent the DidFinishRunningTasks notification from being sent.
 TEST_P(RasterWorkerPoolTest, FalseThrottling) {
   base::Lock lock;
 
   // Schedule a task that is prevented from completing with a lock.
   lock.Acquire();
   AppendBlockingTask(0u, &lock);
   ScheduleTasks();
 
   // Schedule another task to replace the still-pending task. Because the old
   // task is not a throttled task in the new task set, it should not prevent
   // DidFinishRunningTasks from getting signaled.
   tasks_.clear();
-  AppendTask(1u, false);
+  AppendTask(1u);
   ScheduleTasks();
 
   // Unblock the first task to allow the second task to complete.
   lock.Release();
 
   RunMessageLoopUntilAllTasksHaveCompleted();
 }
 
 INSTANTIATE_TEST_CASE_P(RasterWorkerPoolTests,
                         RasterWorkerPoolTest,
                         ::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
-                                          RASTER_WORKER_POOL_TYPE_IMAGE));
+                                          RASTER_WORKER_POOL_TYPE_IMAGE,
+                                          RASTER_WORKER_POOL_TYPE_DIRECT));
 
 }  // namespace
 }  // namespace cc