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

cc/resources/image_raster_worker_pool.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/image_raster_worker_pool.h"
 
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/resource.h"
@@ skipping 10 matching lines @@
   ImageWorkerPoolTaskImpl(internal::RasterWorkerPoolTask* task,
                           uint8_t* buffer,
                           int stride,
                           const Reply& reply)
       : task_(task),
         buffer_(buffer),
         stride_(stride),
         reply_(reply) {
   }
 
-  // Overridden from internal::WorkerPoolTask:
+  // Overridden from internal::Task:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
     TRACE_EVENT0("cc", "ImageWorkerPoolTaskImpl::RunOnWorkerThread");
     if (!buffer_)
       return;
 
     task_->RunOnWorkerThread(thread_index,
                              buffer_,
                              task_->resource()->size(),
                              stride_);
   }
+
+  // Overridden from internal::WorkerPoolTask:
   virtual void CompleteOnOriginThread() OVERRIDE {
     reply_.Run(!HasFinishedRunning());
   }
 
  private:
   virtual ~ImageWorkerPoolTaskImpl() {}
 
   scoped_refptr<internal::RasterWorkerPoolTask> task_;
   uint8_t* buffer_;
   int stride_;
   const Reply reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageWorkerPoolTaskImpl);
 };
 
 }  // namespace
 
 ImageRasterWorkerPool::ImageRasterWorkerPool(
     ResourceProvider* resource_provider,
     ContextProvider* context_provider,
-    GLenum texture_target)
+    unsigned texture_target)
     : RasterWorkerPool(resource_provider, context_provider),
       texture_target_(texture_target),
       raster_tasks_pending_(false),
       raster_tasks_required_for_activation_pending_(false) {
 }
 
 ImageRasterWorkerPool::~ImageRasterWorkerPool() {
   DCHECK_EQ(0u, image_tasks_.size());
 }
 
@@ skipping 87 matching lines @@
   set_raster_required_for_activation_finished_task(
       new_raster_required_for_activation_finished_task);
 
   RunGpuRasterTasks(gpu_raster_tasks);
 
   TRACE_EVENT_ASYNC_STEP_INTO1(
       "cc", "ScheduledTasks", this, "rasterizing",
       "state", TracedValue::FromValue(StateAsValue().release()));
 }
 
-GLenum ImageRasterWorkerPool::GetResourceTarget() const {
+unsigned ImageRasterWorkerPool::GetResourceTarget() const {
   return texture_target_;
 }
 
 ResourceFormat ImageRasterWorkerPool::GetResourceFormat() const {
   return resource_provider()->best_texture_format();
 }
 
 void ImageRasterWorkerPool::OnRasterTasksFinished() {
   DCHECK(raster_tasks_pending_);
   raster_tasks_pending_ = false;
@@ skipping 35 matching lines @@
 
   state->SetBoolean("tasks_required_for_activation_pending",
                     raster_tasks_required_for_activation_pending_);
   state->Set("scheduled_state", ScheduledStateAsValue().release());
   return state.PassAs<base::Value>();
 }
 
 // static
 void ImageRasterWorkerPool::CreateGraphNodeForImageTask(
     internal::WorkerPoolTask* image_task,
-    const TaskVector& decode_tasks,
+    const internal::Task::Vector& decode_tasks,
     unsigned priority,
     bool is_required_for_activation,
     internal::GraphNode* raster_required_for_activation_finished_node,
     internal::GraphNode* raster_finished_node,
     TaskGraph* graph) {
   internal::GraphNode* image_node = CreateGraphNodeForRasterTask(image_task,
                                                                  decode_tasks,
                                                                  priority,
                                                                  graph);
 
   if (is_required_for_activation) {
     raster_required_for_activation_finished_node->add_dependency();
     image_node->add_dependent(raster_required_for_activation_finished_node);
   }
 
   raster_finished_node->add_dependency();
   image_node->add_dependent(raster_finished_node);
 }
 
 }  // namespace cc