Re-land: cc: Remove WorkerPool class and instead use TaskGraphRunner directly.

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 "cc/resources/image_raster_worker_pool.h"
@@ skipping 16 matching lines @@
     RASTER_THREAD_ORIGIN,
     RASTER_THREAD_WORKER
   };
   typedef base::Callback<void(const PicturePileImpl::Analysis& analysis,
                               bool was_canceled,
                               RasterThread raster_thread)> Reply;
 
   TestRasterWorkerPoolTaskImpl(
       const Resource* resource,
       const Reply& reply,
-      TaskVector* dependencies,
+      internal::Task::Vector* dependencies,
       bool use_gpu_rasterization)
       : internal::RasterWorkerPoolTask(resource,
                                        dependencies,
                                        use_gpu_rasterization),
         reply_(reply),
-        raster_thread_(RASTER_THREAD_NONE) {}
+        raster_thread_(RASTER_THREAD_NONE) {
+  }
 
-  // Overridden from internal::WorkerPoolTask:
+  // Overridden from internal::RasterWorkerPoolTask:
   virtual bool RunOnWorkerThread(unsigned thread_index,
                                  void* buffer,
                                  gfx::Size size,
                                  int stride) OVERRIDE {
     raster_thread_ = RASTER_THREAD_WORKER;
     return true;
   }
   virtual void RunOnOriginThread(ResourceProvider* resource_provider,
                                  ContextProvider* context_provider) OVERRIDE {
     raster_thread_ = RASTER_THREAD_ORIGIN;
@@ skipping 12 matching lines @@
   RasterThread raster_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRasterWorkerPoolTaskImpl);
 };
 
 class BlockingRasterWorkerPoolTaskImpl : public TestRasterWorkerPoolTaskImpl {
  public:
   BlockingRasterWorkerPoolTaskImpl(const Resource* resource,
                                    const Reply& reply,
                                    base::Lock* lock,
-                                   TaskVector* dependencies,
+                                   internal::Task::Vector* dependencies,
                                    bool use_gpu_rasterization)
       : TestRasterWorkerPoolTaskImpl(resource,
                                      reply,
                                      dependencies,
                                      use_gpu_rasterization),
-        lock_(lock) {}
+        lock_(lock) {
+  }
 
-  // Overridden from TestRasterWorkerPoolTaskImpl:
+  // Overridden from internal::RasterWorkerPoolTask:
   virtual bool RunOnWorkerThread(unsigned thread_index,
                                  void* buffer,
                                  gfx::Size size,
                                  int stride) OVERRIDE {
     base::AutoLock lock(*lock_);
     return TestRasterWorkerPoolTaskImpl::RunOnWorkerThread(
         thread_index, buffer, size, stride);
   }
   virtual void CompleteOnOriginThread() OVERRIDE {}
 
@@ skipping 365 matching lines @@
   }
 
   base::Lock lock_;
 };
 
 PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestFalseThrottling);
 
 }  // namespace
 
 }  // namespace cc