cc: Move GPU raster to DirectRasterWorkerPool.

cc/resources/raster_worker_pool.cc

Index: cc/resources/raster_worker_pool.cc
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index 630640b6b7a89dad9f0959f9226364052be5a518..3a87c49ce4a63600dda46f4a6c1166d1778392a5 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -69,22 +69,21 @@ class DisableLCDTextFilter : public SkDrawFilter {
 
 class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
  public:
-  RasterWorkerPoolTaskImpl(const Resource* resource,
-                           PicturePileImpl* picture_pile,
-                           const gfx::Rect& content_rect,
-                           float contents_scale,
-                           RasterMode raster_mode,
-                           TileResolution tile_resolution,
-                           int layer_id,
-                           const void* tile_id,
-                           int source_frame_number,
-                           bool use_gpu_rasterization,
-                           RenderingStatsInstrumentation* rendering_stats,
-                           const RasterWorkerPool::RasterTask::Reply& reply,
-                           internal::Task::Vector* dependencies)
-      : internal::RasterWorkerPoolTask(resource,
-                                       dependencies,
-                                       use_gpu_rasterization),
+  RasterWorkerPoolTaskImpl(
+      const Resource* resource,
+      PicturePileImpl* picture_pile,
+      const gfx::Rect& content_rect,
+      float contents_scale,
+      RasterMode raster_mode,
+      TileResolution tile_resolution,
+      int layer_id,
+      const void* tile_id,
+      int source_frame_number,
+      RenderingStatsInstrumentation* rendering_stats,
+      const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply,
+      internal::WorkerPoolTask::Vector* dependencies,
+      ContextProvider* context_provider)
+      : internal::RasterWorkerPoolTask(resource, dependencies),
         picture_pile_(picture_pile),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
@@ -95,6 +94,7 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
         source_frame_number_(source_frame_number),
         rendering_stats_(rendering_stats),
         reply_(reply),
+        context_provider_(context_provider),
         canvas_(NULL) {}
 
   void RunAnalysisOnThread(unsigned thread_index) {
@@ -140,8 +140,6 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
-    // TODO(alokp): For now run-on-worker-thread implies software rasterization.
-    DCHECK(!use_gpu_rasterization());
     RunAnalysisOnThread(thread_index);
     if (canvas_ && !analysis_.is_solid_color)
       RunRasterOnThread(thread_index);
@@ -153,6 +151,20 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
     DCHECK(!canvas_);
     canvas_ = client->AcquireCanvasForRaster(this);
   }
+  virtual void RunOnOriginThread() OVERRIDE {
+    // TODO(alokp): Use a trace macro to push/pop markers.
+    // Using push/pop functions directly incurs cost to evaluate function
+    // arguments even when tracing is disabled.
+    DCHECK(context_provider_);
+    context_provider_->ContextGL()->PushGroupMarkerEXT(
+        0,
+        base::StringPrintf(
+            "Raster-%d-%d-%p", source_frame_number_, layer_id_, tile_id_)
+            .c_str());
+    if (canvas_)
+      Raster(picture_pile_);
+    context_provider_->ContextGL()->PopGroupMarkerEXT();
+  }
   virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
     canvas_ = NULL;
@@ -163,23 +175,6 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
     reply_.Run(analysis_, !HasFinishedRunning());
   }
 
-  // Overridden from internal::RasterWorkerPoolTask:
-  virtual void RunOnOriginThread(ResourceProvider* resource_provider,
-                                 ContextProvider* context_provider) OVERRIDE {
-    // TODO(alokp): Use a trace macro to push/pop markers.
-    // Using push/pop functions directly incurs cost to evaluate function
-    // arguments even when tracing is disabled.
-    context_provider->ContextGL()->PushGroupMarkerEXT(
-        0,
-        base::StringPrintf(
-            "Raster-%d-%d-%p", source_frame_number_, layer_id_, tile_id_)
-            .c_str());
-    // TODO(alokp): For now run-on-origin-thread implies gpu rasterization.
-    DCHECK(use_gpu_rasterization());
-    Raster(picture_pile_);
-    context_provider->ContextGL()->PopGroupMarkerEXT();
-  }
-
  protected:
   virtual ~RasterWorkerPoolTaskImpl() { DCHECK(!canvas_); }
 
@@ -219,6 +214,7 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
     // before we draw and sometimes they aren't)
     RenderingStatsInstrumentation* stats =
         tile_resolution_ == HIGH_RESOLUTION ? rendering_stats_ : NULL;
+    DCHECK(picture_pile);
     picture_pile->RasterToBitmap(
         canvas_, content_rect_, contents_scale_, stats);
 
@@ -244,7 +240,8 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
   const void* tile_id_;
   int source_frame_number_;
   RenderingStatsInstrumentation* rendering_stats_;
-  const RasterWorkerPool::RasterTask::Reply reply_;
+  const base::Callback<void(const PicturePileImpl::Analysis&, bool)> reply_;
+  ContextProvider* context_provider_;
   SkCanvas* canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl);
@@ -252,10 +249,11 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
 
 class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
-  ImageDecodeWorkerPoolTaskImpl(SkPixelRef* pixel_ref,
-                                int layer_id,
-                                RenderingStatsInstrumentation* rendering_stats,
-                                const RasterWorkerPool::Task::Reply& reply)
+  ImageDecodeWorkerPoolTaskImpl(
+      SkPixelRef* pixel_ref,
+      int layer_id,
+      RenderingStatsInstrumentation* rendering_stats,
+      const base::Callback<void(bool was_canceled)>& reply)
       : pixel_ref_(skia::SharePtr(pixel_ref)),
         layer_id_(layer_id),
         rendering_stats_(rendering_stats),
@@ -274,6 +272,7 @@ class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
   // Overridden from internal::WorkerPoolTask:
   virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {}
+  virtual void RunOnOriginThread() OVERRIDE {}
   virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
     client->OnImageDecodeCompleted(this);
@@ -289,7 +288,7 @@ class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
   skia::RefPtr<SkPixelRef> pixel_ref_;
   int layer_id_;
   RenderingStatsInstrumentation* rendering_stats_;
-  const RasterWorkerPool::Task::Reply reply_;
+  const base::Callback<void(bool was_canceled)>& reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeWorkerPoolTaskImpl);
 };
@@ -308,12 +307,21 @@ class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
     TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnWorkerThread");
     origin_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&RasterFinishedWorkerPoolTaskImpl::RunOnOriginThread, this));
+        base::Bind(
+            &RasterFinishedWorkerPoolTaskImpl::OnRasterFinishedOnOriginThread,
+            this));
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {}
+  virtual void RunOnOriginThread() OVERRIDE {
+    origin_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &RasterFinishedWorkerPoolTaskImpl::OnRasterFinishedOnOriginThread,
+            this));
+  }
   virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {}
   virtual void RunReplyOnOriginThread() OVERRIDE {}
@@ -322,7 +330,9 @@ class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
   virtual ~RasterFinishedWorkerPoolTaskImpl() {}
 
  private:
-  void RunOnOriginThread() const { on_raster_finished_callback_.Run(this); }
+  void OnRasterFinishedOnOriginThread() const {
+    on_raster_finished_callback_.Run(this);
+  }
 
   scoped_refptr<base::MessageLoopProxy> origin_loop_;
   const Callback on_raster_finished_callback_;
@@ -411,10 +421,10 @@ void WorkerPoolTask::DidComplete() {
 
 bool WorkerPoolTask::HasCompleted() const { return did_complete_; }
 
-RasterWorkerPoolTask::RasterWorkerPoolTask(const Resource* resource,
-                                           internal::Task::Vector* dependencies,
-                                           bool use_gpu_rasterization)
-    : resource_(resource), use_gpu_rasterization_(use_gpu_rasterization) {
+RasterWorkerPoolTask::RasterWorkerPoolTask(
+    const Resource* resource,
+    internal::WorkerPoolTask::Vector* dependencies)
+    : resource_(resource) {
   dependencies_.swap(*dependencies);
 }
 
@@ -422,64 +432,27 @@ RasterWorkerPoolTask::~RasterWorkerPoolTask() {}
 
 }  // namespace internal
 
-RasterWorkerPool::Task::Set::Set() {}
-
-RasterWorkerPool::Task::Set::~Set() {}
-
-void RasterWorkerPool::Task::Set::Insert(const Task& task) {
-  DCHECK(!task.is_null());
-  tasks_.push_back(task.internal_);
-}
-
-RasterWorkerPool::Task::Task() {}
-
-RasterWorkerPool::Task::Task(internal::WorkerPoolTask* internal)
-    : internal_(internal) {}
-
-RasterWorkerPool::Task::~Task() {}
-
-void RasterWorkerPool::Task::Reset() { internal_ = NULL; }
-
-RasterWorkerPool::RasterTask::Queue::QueuedTask::QueuedTask(
-    internal::RasterWorkerPoolTask* task,
-    bool required_for_activation)
+RasterTaskQueue::Task::Task(internal::RasterWorkerPoolTask* task,
+                            bool required_for_activation)
     : task(task), required_for_activation(required_for_activation) {}
 
-RasterWorkerPool::RasterTask::Queue::QueuedTask::~QueuedTask() {}
+RasterTaskQueue::Task::~Task() {}
 
-RasterWorkerPool::RasterTask::Queue::Queue()
-    : required_for_activation_count_(0u) {}
+RasterTaskQueue::RasterTaskQueue() : required_for_activation_count(0u) {}
 
-RasterWorkerPool::RasterTask::Queue::~Queue() {}
+RasterTaskQueue::~RasterTaskQueue() {}
 
-void RasterWorkerPool::RasterTask::Queue::Reset() {
-  tasks_.clear();
-  required_for_activation_count_ = 0u;
+void RasterTaskQueue::Swap(RasterTaskQueue* other) {
+  tasks.swap(other->tasks);
+  std::swap(required_for_activation_count,
+            other->required_for_activation_count);
 }
 
-void RasterWorkerPool::RasterTask::Queue::Append(const RasterTask& task,
-                                                 bool required_for_activation) {
-  DCHECK(!task.is_null());
-  tasks_.push_back(QueuedTask(task.internal_, required_for_activation));
-  required_for_activation_count_ += required_for_activation;
+void RasterTaskQueue::Reset() {
+  required_for_activation_count = 0u;
+  tasks.clear();
 }
 
-void RasterWorkerPool::RasterTask::Queue::Swap(Queue* other) {
-  tasks_.swap(other->tasks_);
-  std::swap(required_for_activation_count_,
-            other->required_for_activation_count_);
-}
-
-RasterWorkerPool::RasterTask::RasterTask() {}
-
-RasterWorkerPool::RasterTask::RasterTask(
-    internal::RasterWorkerPoolTask* internal)
-    : internal_(internal) {}
-
-void RasterWorkerPool::RasterTask::Reset() { internal_ = NULL; }
-
-RasterWorkerPool::RasterTask::~RasterTask() {}
-
 // This allows an external rasterize on-demand system to run raster tasks
 // with highest priority using the same task graph runner instance.
 unsigned RasterWorkerPool::kOnDemandRasterTaskPriority = 0u;
@@ -491,14 +464,14 @@ unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority =
 unsigned RasterWorkerPool::kRasterTaskPriorityBase = 3u;
 
 RasterWorkerPool::RasterWorkerPool(internal::TaskGraphRunner* task_graph_runner,
-                                   ResourceProvider* resource_provider,
-                                   ContextProvider* context_provider)
+                                   ResourceProvider* resource_provider)
     : task_graph_runner_(task_graph_runner),
-      namespace_token_(task_graph_runner_->GetNamespaceToken()),
       client_(NULL),
       resource_provider_(resource_provider),
-      context_provider_(context_provider),
-      weak_ptr_factory_(this) {}
+      weak_ptr_factory_(this) {
+  if (task_graph_runner_)
+    namespace_token_ = task_graph_runner_->GetNamespaceToken();
+}
 
 RasterWorkerPool::~RasterWorkerPool() {}
 
@@ -524,7 +497,8 @@ internal::TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
 }
 
 // static
-RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
+scoped_refptr<internal::RasterWorkerPoolTask>
+RasterWorkerPool::CreateRasterTask(
     const Resource* resource,
     PicturePileImpl* picture_pile,
     const gfx::Rect& content_rect,
@@ -534,32 +508,32 @@ RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
     int layer_id,
     const void* tile_id,
     int source_frame_number,
-    bool use_gpu_rasterization,
     RenderingStatsInstrumentation* rendering_stats,
-    const RasterTask::Reply& reply,
-    Task::Set* dependencies) {
-  return RasterTask(new RasterWorkerPoolTaskImpl(resource,
-                                                 picture_pile,
-                                                 content_rect,
-                                                 contents_scale,
-                                                 raster_mode,
-                                                 tile_resolution,
-                                                 layer_id,
-                                                 tile_id,
-                                                 source_frame_number,
-                                                 use_gpu_rasterization,
-                                                 rendering_stats,
-                                                 reply,
-                                                 &dependencies->tasks_));
+    const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply,
+    internal::WorkerPoolTask::Vector* dependencies,
+    ContextProvider* context_provider) {
+  return make_scoped_refptr(new RasterWorkerPoolTaskImpl(resource,
+                                                         picture_pile,
+                                                         content_rect,
+                                                         contents_scale,
+                                                         raster_mode,
+                                                         tile_resolution,
+                                                         layer_id,
+                                                         tile_id,
+                                                         source_frame_number,
+                                                         rendering_stats,
+                                                         reply,
+                                                         dependencies,
+                                                         context_provider));
 }
 
 // static
-RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask(
+scoped_refptr<internal::WorkerPoolTask> RasterWorkerPool::CreateImageDecodeTask(
     SkPixelRef* pixel_ref,
     int layer_id,
     RenderingStatsInstrumentation* rendering_stats,
-    const Task::Reply& reply) {
-  return Task(new ImageDecodeWorkerPoolTaskImpl(
+    const base::Callback<void(bool was_canceled)>& reply) {
+  return make_scoped_refptr(new ImageDecodeWorkerPoolTaskImpl(
       pixel_ref, layer_id, rendering_stats, reply));
 }
 
@@ -570,15 +544,19 @@ void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
 void RasterWorkerPool::Shutdown() {
   TRACE_EVENT0("cc", "RasterWorkerPool::Shutdown");
 
-  internal::TaskGraph empty;
-  SetTaskGraph(&empty);
-  task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
+  if (task_graph_runner_) {
+    internal::TaskGraph empty;
+    task_graph_runner_->SetTaskGraph(namespace_token_, &empty);
+    task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
+  }
+
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void RasterWorkerPool::SetTaskGraph(internal::TaskGraph* graph) {
   TRACE_EVENT0("cc", "RasterWorkerPool::SetTaskGraph");
 
+  DCHECK(task_graph_runner_);
   for (internal::TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
        it != graph->nodes.end();
        ++it) {
@@ -598,55 +576,10 @@ void RasterWorkerPool::SetTaskGraph(internal::TaskGraph* graph) {
 
 void RasterWorkerPool::CollectCompletedWorkerPoolTasks(
     internal::Task::Vector* completed_tasks) {
+  DCHECK(task_graph_runner_);
   task_graph_runner_->CollectCompletedTasks(namespace_token_, completed_tasks);
 }
 
-void RasterWorkerPool::RunGpuRasterTasks(const RasterTaskVector& tasks) {
-  DCHECK(!tasks.empty());
-  TRACE_EVENT1(
-      "cc", "RasterWorkerPool::RunGpuRasterTasks", "num_tasks", tasks.size());
-
-  GrContext* gr_context = context_provider_->GrContext();
-  // TODO(alokp): Implement TestContextProvider::GrContext().
-  if (gr_context)
-    gr_context->resetContext();
-
-  for (RasterTaskVector::const_iterator it = tasks.begin(); it != tasks.end();
-       ++it) {
-    internal::RasterWorkerPoolTask* task = it->get();
-    DCHECK(task->use_gpu_rasterization());
-
-    task->WillSchedule();
-    task->ScheduleOnOriginThread(this);
-    task->DidSchedule();
-
-    task->WillRun();
-    task->RunOnOriginThread(resource_provider_, context_provider_);
-    task->DidRun();
-
-    task->WillComplete();
-    task->CompleteOnOriginThread(this);
-    task->DidComplete();
-
-    completed_gpu_raster_tasks_.push_back(task);
-  }
-
-  // TODO(alokp): Implement TestContextProvider::GrContext().
-  if (gr_context)
-    gr_context->flush();
-}
-
-void RasterWorkerPool::CheckForCompletedGpuRasterTasks() {
-  // Complete gpu rasterization tasks.
-  while (!completed_gpu_raster_tasks_.empty()) {
-    internal::WorkerPoolTask* task = completed_gpu_raster_tasks_.front().get();
-
-    task->RunReplyOnOriginThread();
-
-    completed_gpu_raster_tasks_.pop_front();
-  }
-}
-
 scoped_refptr<internal::WorkerPoolTask>
 RasterWorkerPool::CreateRasterFinishedTask() {
   return make_scoped_refptr(new RasterFinishedWorkerPoolTaskImpl(base::Bind(
@@ -663,6 +596,20 @@ RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask(
           tasks_required_for_activation_count));
 }
 
+void RasterWorkerPool::RunTaskOnOriginThread(internal::WorkerPoolTask* task) {
+  task->WillSchedule();
+  task->ScheduleOnOriginThread(this);
+  task->DidSchedule();
+
+  task->WillRun();
+  task->RunOnOriginThread();
+  task->DidRun();
+
+  task->WillComplete();
+  task->CompleteOnOriginThread(this);
+  task->DidComplete();
+}
+
 void RasterWorkerPool::OnRasterFinished(
     const internal::WorkerPoolTask* source) {
   TRACE_EVENT0("cc", "RasterWorkerPool::OnRasterFinished");
@@ -703,16 +650,16 @@ void RasterWorkerPool::InsertNodeForTask(internal::TaskGraph* graph,
 void RasterWorkerPool::InsertNodeForRasterTask(
     internal::TaskGraph* graph,
     internal::WorkerPoolTask* raster_task,
-    const internal::Task::Vector& decode_tasks,
+    const internal::WorkerPoolTask::Vector& decode_tasks,
     unsigned priority) {
   size_t dependencies = 0u;
 
   // Insert image decode tasks.
-  for (internal::Task::Vector::const_iterator it = decode_tasks.begin();
+  for (internal::WorkerPoolTask::Vector::const_iterator it =
+           decode_tasks.begin();
        it != decode_tasks.end();
        ++it) {
-    internal::WorkerPoolTask* decode_task =
-        static_cast<internal::WorkerPoolTask*>(it->get());
+    internal::WorkerPoolTask* decode_task = it->get();
 
     // Skip if already decoded.
     if (decode_task->HasCompleted())