cc: Separate RasterWorkerPool interface from implementation details.

cc/resources/raster_worker_pool_unittest.cc

Index: cc/resources/raster_worker_pool_unittest.cc
diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/raster_worker_pool_unittest.cc
index a7e18fff80c8de762ad7cb493b52548630d7c4fa..52b3a26abe5db90a8c3e667e3848554577028284 100644
--- a/cc/resources/raster_worker_pool_unittest.cc
+++ b/cc/resources/raster_worker_pool_unittest.cc
@@ -13,6 +13,7 @@
 #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/rasterizer.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/test/fake_output_surface.h"
@@ -36,16 +37,16 @@ enum RasterWorkerPoolType {
   RASTER_WORKER_POOL_TYPE_DIRECT
 };
 
-class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
+class TestRasterTaskImpl : public internal::RasterTask {
  public:
   typedef base::Callback<void(const PicturePileImpl::Analysis& analysis,
                               bool was_canceled,
                               RasterThread raster_thread)> Reply;
 
-  TestRasterWorkerPoolTaskImpl(const Resource* resource,
-                               const Reply& reply,
-                               internal::WorkerPoolTask::Vector* dependencies)
-      : internal::RasterWorkerPoolTask(resource, dependencies),
+  TestRasterTaskImpl(const Resource* resource,
+                     const Reply& reply,
+                     internal::ImageDecodeTask::Vector* dependencies)
+      : internal::RasterTask(resource, dependencies),
         reply_(reply),
         raster_thread_(RASTER_THREAD_NONE) {}
 
@@ -54,17 +55,17 @@ class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
     raster_thread_ = RASTER_THREAD_WORKER;
   }
 
-  // Overridden from internal::WorkerPoolTask:
-  virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
+  // Overridden from internal::RasterizerTask:
+  virtual void ScheduleOnOriginThread(internal::RasterizerTaskClient* client)
       OVERRIDE {
-    client->AcquireCanvasForRaster(this, resource());
+    client->AcquireCanvasForRaster(this);
   }
   virtual void RunOnOriginThread() OVERRIDE {
     raster_thread_ = RASTER_THREAD_ORIGIN;
   }
-  virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
+  virtual void CompleteOnOriginThread(internal::RasterizerTaskClient* client)
       OVERRIDE {
-    client->ReleaseCanvasForRaster(this, resource());
+    client->ReleaseCanvasForRaster(this);
   }
   virtual void RunReplyOnOriginThread() OVERRIDE {
     reply_.Run(
@@ -72,47 +73,44 @@ class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
   }
 
  protected:
-  virtual ~TestRasterWorkerPoolTaskImpl() {}
+  virtual ~TestRasterTaskImpl() {}
 
  private:
   const Reply reply_;
   RasterThread raster_thread_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestRasterWorkerPoolTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl);
 };
 
-class BlockingTestRasterWorkerPoolTaskImpl
-    : public TestRasterWorkerPoolTaskImpl {
+class BlockingTestRasterTaskImpl : public TestRasterTaskImpl {
  public:
-  BlockingTestRasterWorkerPoolTaskImpl(
-      const Resource* resource,
-      const Reply& reply,
-      base::Lock* lock,
-      internal::WorkerPoolTask::Vector* dependencies)
-      : TestRasterWorkerPoolTaskImpl(resource, reply, dependencies),
-        lock_(lock) {}
+  BlockingTestRasterTaskImpl(const Resource* resource,
+                             const Reply& reply,
+                             base::Lock* lock,
+                             internal::ImageDecodeTask::Vector* dependencies)
+      : TestRasterTaskImpl(resource, reply, dependencies), lock_(lock) {}
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     base::AutoLock lock(*lock_);
-    TestRasterWorkerPoolTaskImpl::RunOnWorkerThread();
+    TestRasterTaskImpl::RunOnWorkerThread();
   }
 
-  // Overridden from internal::WorkerPoolTask:
+  // Overridden from internal::RasterizerTask:
   virtual void RunReplyOnOriginThread() OVERRIDE {}
 
  protected:
-  virtual ~BlockingTestRasterWorkerPoolTaskImpl() {}
+  virtual ~BlockingTestRasterTaskImpl() {}
 
  private:
   base::Lock* lock_;
 
-  DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterWorkerPoolTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl);
 };
 
 class RasterWorkerPoolTest
     : public testing::TestWithParam<RasterWorkerPoolType>,
-      public RasterWorkerPoolClient {
+      public RasterizerClient {
  public:
   struct RasterTaskResult {
     unsigned id;
@@ -120,8 +118,7 @@ class RasterWorkerPoolTest
     RasterThread raster_thread;
   };
 
-  typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
-      RasterTaskVector;
+  typedef std::vector<scoped_refptr<internal::RasterTask> > RasterTaskVector;
 
   RasterWorkerPoolTest()
       : context_provider_(TestContextProvider::Create()),
@@ -135,49 +132,48 @@ class RasterWorkerPoolTest
         ResourceProvider::Create(
             output_surface_.get(), shared_bitmap_manager_.get(), 0, false, 1)
             .Pass();
-    pixel_buffer_raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
-        base::MessageLoopProxy::current().get(),
-        resource_provider_.get(),
-        std::numeric_limits<size_t>::max());
-    image_raster_worker_pool_ =
-        ImageRasterWorkerPool::Create(base::MessageLoopProxy::current().get(),
-                                      resource_provider_.get(),
-                                      GL_TEXTURE_2D);
-    direct_raster_worker_pool_ =
-        DirectRasterWorkerPool::Create(base::MessageLoopProxy::current().get(),
-                                       resource_provider_.get(),
-                                       context_provider_.get());
 
     switch (GetParam()) {
       case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
-        raster_worker_pool_ = pixel_buffer_raster_worker_pool_.get();
+        raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
+            base::MessageLoopProxy::current().get(),
+            RasterWorkerPool::GetTaskGraphRunner(),
+            resource_provider_.get(),
+            std::numeric_limits<size_t>::max());
         break;
       case RASTER_WORKER_POOL_TYPE_IMAGE:
-        raster_worker_pool_ = image_raster_worker_pool_.get();
+        raster_worker_pool_ = ImageRasterWorkerPool::Create(
+            base::MessageLoopProxy::current().get(),
+            RasterWorkerPool::GetTaskGraphRunner(),
+            resource_provider_.get(),
+            GL_TEXTURE_2D);
         break;
       case RASTER_WORKER_POOL_TYPE_DIRECT:
-        raster_worker_pool_ = direct_raster_worker_pool_.get();
+        raster_worker_pool_ = DirectRasterWorkerPool::Create(
+            base::MessageLoopProxy::current().get(),
+            resource_provider_.get(),
+            context_provider_.get());
         break;
     }
 
     DCHECK(raster_worker_pool_);
-    raster_worker_pool_->SetClient(this);
+    raster_worker_pool_->AsRasterizer()->SetClient(this);
   }
   virtual ~RasterWorkerPoolTest() { resource_provider_.reset(); }
 
   // Overridden from testing::Test:
   virtual void TearDown() OVERRIDE {
-    raster_worker_pool_->Shutdown();
-    raster_worker_pool_->CheckForCompletedTasks();
+    raster_worker_pool_->AsRasterizer()->Shutdown();
+    raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
   }
 
   // Overriden from RasterWorkerPoolClient:
-  virtual bool ShouldForceTasksRequiredForActivationToComplete()
-      const OVERRIDE {
+  virtual bool ShouldForceTasksRequiredForActivationToComplete() const
+      OVERRIDE {
     return false;
   }
   virtual void DidFinishRunningTasks() OVERRIDE {
-    raster_worker_pool_->CheckForCompletedTasks();
+    raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
     base::MessageLoop::current()->Quit();
   }
   virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE {}
@@ -207,7 +203,7 @@ class RasterWorkerPoolTest
          ++it)
       queue.items.push_back(RasterTaskQueue::Item(*it, false));
 
-    raster_worker_pool_->ScheduleTasks(&queue);
+    raster_worker_pool_->AsRasterizer()->ScheduleTasks(&queue);
   }
 
   void AppendTask(unsigned id) {
@@ -218,8 +214,8 @@ class RasterWorkerPoolTest
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
-    internal::WorkerPoolTask::Vector empty;
-    tasks_.push_back(new TestRasterWorkerPoolTaskImpl(
+    internal::ImageDecodeTask::Vector empty;
+    tasks_.push_back(new TestRasterTaskImpl(
         const_resource,
         base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                    base::Unretained(this),
@@ -236,8 +232,8 @@ class RasterWorkerPoolTest
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
-    internal::WorkerPoolTask::Vector empty;
-    tasks_.push_back(new BlockingTestRasterWorkerPoolTaskImpl(
+    internal::ImageDecodeTask::Vector empty;
+    tasks_.push_back(new BlockingTestRasterTaskImpl(
         const_resource,
         base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                    base::Unretained(this),
@@ -275,10 +271,7 @@ class RasterWorkerPoolTest
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
-  scoped_ptr<PixelBufferRasterWorkerPool> pixel_buffer_raster_worker_pool_;
-  scoped_ptr<ImageRasterWorkerPool> image_raster_worker_pool_;
-  scoped_ptr<DirectRasterWorkerPool> direct_raster_worker_pool_;
-  RasterWorkerPool* raster_worker_pool_;
+  scoped_ptr<RasterWorkerPool> raster_worker_pool_;
   base::CancelableClosure timeout_;
   int timeout_seconds_;
   bool timed_out_;