cc: Remove RasterWorkerPool::Task.

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"
@@ skipping 95 matching lines @@
  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) {
-      internal::WorkerPoolTask::Vector dependencies;
-      return RasterTask(
-          new TestRasterWorkerPoolTaskImpl(resource, reply, &dependencies));
-    }
-
-    static RasterTask CreateBlocking(
-        const Resource* resource,
-        const TestRasterWorkerPoolTaskImpl::Reply& reply,
-        base::Lock* lock) {
-      internal::WorkerPoolTask::Vector dependencies;
-      return RasterTask(new BlockingTestRasterWorkerPoolTaskImpl(
-          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;
   };
 
+  typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
+      RasterTaskVector;
+
   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();
 
@@ skipping 46 matching lines @@
     }
 
     base::MessageLoop::current()->Run();
 
     timeout_.Cancel();
 
     ASSERT_FALSE(timed_out_) << "Test timed out";
   }
 
   void ScheduleTasks() {
-    RasterWorkerPool::RasterTask::Queue queue;
+    RasterTaskQueue queue;
 
-    for (RasterTask::Vector::iterator it = tasks_.begin(); it != tasks_.end();
+    for (RasterTaskVector::const_iterator it = tasks_.begin();
+         it != tasks_.end();
          ++it)
-      queue.Append(*it, false);
+      queue.items.push_back(RasterTaskQueue::Item(*it, false));
 
     raster_worker_pool_->ScheduleTasks(&queue);
   }
 
   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)));
+    internal::WorkerPoolTask::Vector empty;
+    tasks_.push_back(new TestRasterWorkerPoolTaskImpl(
+        const_resource,
+        base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
+                   base::Unretained(this),
+                   base::Passed(&resource),
+                   id),
+        &empty));
   }
 
   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(
+    internal::WorkerPoolTask::Vector empty;
+    tasks_.push_back(new BlockingTestRasterWorkerPoolTaskImpl(
         const_resource,
         base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                    base::Unretained(this),
                    base::Passed(&resource),
                    id),
-        lock));
+        lock,
+        &empty));
   }
 
   const std::vector<RasterTaskResult>& completed_tasks() const {
     return completed_tasks_;
   }
 
  private:
   void OnTaskCompleted(scoped_ptr<ScopedResource> resource,
                        unsigned id,
                        const PicturePileImpl::Analysis& analysis,
@@ skipping 13 matching lines @@
 
  protected:
   scoped_refptr<TestContextProvider> context_provider_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<RasterWorkerPool> raster_worker_pool_;
   base::CancelableClosure timeout_;
   int timeout_seconds_;
   bool timed_out_;
-  std::vector<RasterTask> tasks_;
+  RasterTaskVector tasks_;
   std::vector<RasterTaskResult> completed_tasks_;
 };
 
 TEST_P(RasterWorkerPoolTest, Basic) {
   AppendTask(0u);
   AppendTask(1u);
   ScheduleTasks();
 
   RunMessageLoopUntilAllTasksHaveCompleted();
 
@@ skipping 42 matching lines @@
 }
 
 INSTANTIATE_TEST_CASE_P(RasterWorkerPoolTests,
                         RasterWorkerPoolTest,
                         ::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
                                           RASTER_WORKER_POOL_TYPE_IMAGE,
                                           RASTER_WORKER_POOL_TYPE_DIRECT));
 
 }  // namespace
 }  // namespace cc