cc: Move GPU raster to DirectRasterWorkerPool.

cc/resources/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/raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event_synthetic_delay.h"
 #include "base/json/json_writer.h"
@@ skipping 60 matching lines @@
  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),
+                           internal::WorkerPoolTask::Vector* dependencies,
+                           ContextProvider* context_provider)
+      : internal::RasterWorkerPoolTask(resource, dependencies),
         picture_pile_(picture_pile),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         raster_mode_(raster_mode),
         tile_resolution_(tile_resolution),
         layer_id_(layer_id),
         tile_id_(tile_id),
         source_frame_number_(source_frame_number),
         rendering_stats_(rendering_stats),
         reply_(reply),
+        context_provider_(context_provider),
         canvas_(NULL) {}
 
-  void RunAnalysisOnThread(unsigned thread_index) {
-    TRACE_EVENT1("cc",
-                 "RasterWorkerPoolTaskImpl::RunAnalysisOnThread",
-                 "data",
-                 TracedValue::FromValue(DataAsValue().release()));
+  // Overridden from internal::Task:
+  virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
+    TRACE_EVENT0("cc", "RasterWorkerPoolTaskImpl::RunOnWorkerThread");
 
-    DCHECK(picture_pile_.get());
-    DCHECK(rendering_stats_);
-
-    PicturePileImpl* picture_clone =
-        picture_pile_->GetCloneForDrawingOnThread(thread_index);
-
-    DCHECK(picture_clone);
-
-    picture_clone->AnalyzeInRect(
-        content_rect_, contents_scale_, &analysis_, rendering_stats_);
-
-    // Record the solid color prediction.
-    UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
-                          analysis_.is_solid_color);
-
-    // Clear the flag if we're not using the estimator.
-    analysis_.is_solid_color &= kUseColorEstimator;
-  }
-
-  void RunRasterOnThread(unsigned thread_index) {
-    TRACE_EVENT2(
-        "cc",
-        "RasterWorkerPoolTaskImpl::RunRasterOnThread",
-        "data",
-        TracedValue::FromValue(DataAsValue().release()),
-        "raster_mode",
-        TracedValue::FromValue(RasterModeAsValue(raster_mode_).release()));
-
-    devtools_instrumentation::ScopedLayerTask raster_task(
-        devtools_instrumentation::kRasterTask, layer_id_);
-
-    DCHECK(picture_pile_.get());
+    DCHECK(picture_pile_);
+    Analyze(picture_pile_->GetCloneForDrawingOnThread(thread_index));
+    if (!canvas_ && analysis_.is_solid_color)
+      return;
     Raster(picture_pile_->GetCloneForDrawingOnThread(thread_index));
   }
 
-  // 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);
-  }
-
   // Overridden from internal::WorkerPoolTask:
   virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
     DCHECK(!canvas_);
     canvas_ = client->AcquireCanvasForRaster(this);
   }
+  virtual void RunOnOriginThread() OVERRIDE {

[reveman, 2014/02/14 23:30:52]

This shouldn't behave any different from RunOnWorkerThread except that there's
no need to use a picture clone.

FYI, this now calls Analyze as it should. Maybe we should add a flag to disable
that if it's not something we like to do for gpu raster. The flag should apply
to both RunOnWorkerThread and RunOnOriginThread. It might be easiest to wait
until TileVersion is a Task before we do this..

+    TRACE_EVENT0("cc", "RasterWorkerPoolTaskImpl::RunOnOriginThread");
+
+    Analyze(picture_pile_);
+    if (!canvas_ && analysis_.is_solid_color)
+      return;
+    // 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());
+    Raster(picture_pile_);
+    context_provider_->ContextGL()->PopGroupMarkerEXT();
+  }
   virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
     canvas_ = NULL;
     client->OnRasterCompleted(this, analysis_);
   }
   virtual void RunReplyOnOriginThread() OVERRIDE {
     DCHECK(!canvas_);
     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_); }
 
  private:
   scoped_ptr<base::Value> DataAsValue() const {
     scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
     res->Set("tile_id", TracedValue::CreateIDRef(tile_id_).release());
     res->Set("resolution", TileResolutionAsValue(tile_resolution_).release());
     res->SetInteger("source_frame_number", source_frame_number_);
     res->SetInteger("layer_id", layer_id_);
     return res.PassAs<base::Value>();
   }
 
+  void Analyze(PicturePileImpl* picture_pile) {
+    TRACE_EVENT1("cc",
+                 "RasterWorkerPoolTaskImpl::Analyze",
+                 "data",
+                 TracedValue::FromValue(DataAsValue().release()));
+
+    DCHECK(picture_pile);
+
+    picture_pile->AnalyzeInRect(
+        content_rect_, contents_scale_, &analysis_, rendering_stats_);
+
+    // Record the solid color prediction.
+    UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
+                          analysis_.is_solid_color);
+
+    // Clear the flag if we're not using the estimator.
+    analysis_.is_solid_color &= kUseColorEstimator;
+  }
+
   void Raster(PicturePileImpl* picture_pile) {
+    TRACE_EVENT2(
+        "cc",
+        "RasterWorkerPoolTaskImpl::Raster",
+        "data",
+        TracedValue::FromValue(DataAsValue().release()),
+        "raster_mode",
+        TracedValue::FromValue(RasterModeAsValue(raster_mode_).release()));
+
+    devtools_instrumentation::ScopedLayerTask raster_task(
+        devtools_instrumentation::kRasterTask, layer_id_);
+
     skia::RefPtr<SkDrawFilter> draw_filter;
     switch (raster_mode_) {
       case LOW_QUALITY_RASTER_MODE:
         draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
         break;
       case HIGH_QUALITY_NO_LCD_RASTER_MODE:
         draw_filter = skia::AdoptRef(new DisableLCDTextFilter);
         break;
       case HIGH_QUALITY_RASTER_MODE:
         break;
       case NUM_RASTER_MODES:
       default:
         NOTREACHED();
     }
     canvas_->setDrawFilter(draw_filter.get());
 
     base::TimeDelta prev_rasterize_time =
         rendering_stats_->impl_thread_rendering_stats().rasterize_time;
 
     // Only record rasterization time for highres tiles, because
     // lowres tiles are not required for activation and therefore
     // introduce noise in the measurement (sometimes they get rasterized
     // 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);
 
     if (rendering_stats_->record_rendering_stats()) {
       base::TimeDelta current_rasterize_time =
           rendering_stats_->impl_thread_rendering_stats().rasterize_time;
       HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
           (current_rasterize_time - prev_rasterize_time).InMicroseconds(),
           0,
           100000,
           100);
     }
   }
 
   PicturePileImpl::Analysis analysis_;
   scoped_refptr<PicturePileImpl> picture_pile_;
   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 RasterWorkerPool::RasterTask::Reply reply_;
+  ContextProvider* context_provider_;
   SkCanvas* canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl);
 };
 
 class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   ImageDecodeWorkerPoolTaskImpl(SkPixelRef* pixel_ref,
                                 int layer_id,
                                 RenderingStatsInstrumentation* rendering_stats,
                                 const RasterWorkerPool::Task::Reply& reply)
       : pixel_ref_(skia::SharePtr(pixel_ref)),
         layer_id_(layer_id),
         rendering_stats_(rendering_stats),
         reply_(reply) {}
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
     TRACE_EVENT0("cc", "ImageDecodeWorkerPoolTaskImpl::RunOnWorkerThread");
-    devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
-        pixel_ref_.get());
-    // This will cause the image referred to by pixel ref to be decoded.
-    pixel_ref_->lockPixels();
-    pixel_ref_->unlockPixels();
+    Decode();
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {}
+  virtual void RunOnOriginThread() OVERRIDE {
+    TRACE_EVENT0("cc", "ImageDecodeWorkerPoolTaskImpl::RunOnOriginThread");
+    Decode();
+  }
   virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
     client->OnImageDecodeCompleted(this);
   }
   virtual void RunReplyOnOriginThread() OVERRIDE {
     reply_.Run(!HasFinishedRunning());
   }
 
  protected:
   virtual ~ImageDecodeWorkerPoolTaskImpl() {}
 
  private:
+  void Decode() {
+    devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
+        pixel_ref_.get());
+    // This will cause the image referred to by pixel ref to be decoded.
+    pixel_ref_->lockPixels();
+    pixel_ref_->unlockPixels();
+  }
+
   skia::RefPtr<SkPixelRef> pixel_ref_;
   int layer_id_;
   RenderingStatsInstrumentation* rendering_stats_;
   const RasterWorkerPool::Task::Reply reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeWorkerPoolTaskImpl);
 };
 
 class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   typedef base::Callback<void(const internal::WorkerPoolTask* source)> Callback;
 
   explicit RasterFinishedWorkerPoolTaskImpl(
       const Callback& on_raster_finished_callback)
       : origin_loop_(base::MessageLoopProxy::current().get()),
         on_raster_finished_callback_(on_raster_finished_callback) {}
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
     TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnWorkerThread");
-    origin_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&RasterFinishedWorkerPoolTaskImpl::RunOnOriginThread, this));
+    RasterFinished();
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {}
+  virtual void RunOnOriginThread() OVERRIDE {
+    TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnOriginThread");
+    RasterFinished();
+  }
   virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {}
   virtual void RunReplyOnOriginThread() OVERRIDE {}
 
  protected:
   virtual ~RasterFinishedWorkerPoolTaskImpl() {}
 
+  void RasterFinished() {
+    origin_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &RasterFinishedWorkerPoolTaskImpl::OnRasterFinishedOnOriginThread,
+            this));
+  }
+
  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_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterFinishedWorkerPoolTaskImpl);
 };
 
 class RasterRequiredForActivationFinishedWorkerPoolTaskImpl
     : public RasterFinishedWorkerPoolTaskImpl {
  public:
   RasterRequiredForActivationFinishedWorkerPoolTaskImpl(
       const Callback& on_raster_finished_callback,
       size_t tasks_required_for_activation_count)
       : RasterFinishedWorkerPoolTaskImpl(on_raster_finished_callback),
         tasks_required_for_activation_count_(
             tasks_required_for_activation_count) {
     if (tasks_required_for_activation_count_) {
       g_raster_required_for_activation_delay.Get().delay->BeginParallel(
           &activation_delay_end_time_);
     }
   }
 
-  // Overridden from RasterFinishedWorkerPoolTaskImpl:
+  // Overridden from internal::Task:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
     TRACE_EVENT0("cc",
                  "RasterRequiredForActivationFinishedWorkerPoolTaskImpl::"
                  "RunOnWorkerThread");
-    if (tasks_required_for_activation_count_) {
-      g_raster_required_for_activation_delay.Get().delay->EndParallel(
-          activation_delay_end_time_);
-    }
-    RasterFinishedWorkerPoolTaskImpl::RunOnWorkerThread(thread_index);
+    RunRasterFinished();
+  }
+
+  // Overridden from internal::WorkerPoolTask:
+  virtual void RunOnOriginThread() OVERRIDE {
+    TRACE_EVENT0("cc",
+                 "RasterRequiredForActivationFinishedWorkerPoolTaskImpl::"
+                 "RunOnOriginThread");
+    RunRasterFinished();
   }
 
  private:
   virtual ~RasterRequiredForActivationFinishedWorkerPoolTaskImpl() {}
 
+  void RunRasterFinished() {
+    if (tasks_required_for_activation_count_) {
+      g_raster_required_for_activation_delay.Get().delay->EndParallel(
+          activation_delay_end_time_);
+    }
+    RasterFinished();
+  }
+
   base::TimeTicks activation_delay_end_time_;
   const size_t tasks_required_for_activation_count_;
 
   DISALLOW_COPY_AND_ASSIGN(
       RasterRequiredForActivationFinishedWorkerPoolTaskImpl);
 };
 
 class RasterTaskGraphRunner : public internal::TaskGraphRunner {
  public:
   RasterTaskGraphRunner()
@@ skipping 31 matching lines @@
 
 void WorkerPoolTask::DidComplete() {
   DCHECK(did_schedule_);
   DCHECK(!did_complete_);
   did_schedule_ = false;
   did_complete_ = true;
 }
 
 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);
 }
 
 RasterWorkerPoolTask::~RasterWorkerPoolTask() {}
 
 }  // namespace internal
 
 RasterWorkerPool::Task::Set::Set() {}
 
 RasterWorkerPool::Task::Set::~Set() {}
@@ skipping 56 matching lines @@
 // with highest priority using the same task graph runner instance.
 unsigned RasterWorkerPool::kOnDemandRasterTaskPriority = 0u;
 // Task priorities that make sure raster finished tasks run before any
 // remaining raster tasks.
 unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 2u;
 unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority =
     1u;
 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() {}
 
 // static
 void RasterWorkerPool::SetNumRasterThreads(int num_threads) {
   DCHECK_LT(0, num_threads);
   DCHECK_EQ(0, g_num_raster_threads);
 
   g_num_raster_threads = num_threads;
 }
@@ skipping 15 matching lines @@
 RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
     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 RasterTask::Reply& reply,
-    Task::Set* dependencies) {
+    Task::Set* dependencies,
+    ContextProvider* context_provider) {
   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_));
+                                                 &dependencies->tasks_,
+                                                 context_provider));
 }
 
 // static
 RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask(
     SkPixelRef* pixel_ref,
     int layer_id,
     RenderingStatsInstrumentation* rendering_stats,
     const Task::Reply& reply) {
   return Task(new ImageDecodeWorkerPoolTaskImpl(
       pixel_ref, layer_id, rendering_stats, reply));
 }
 
 void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
   client_ = 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) {
     internal::TaskGraph::Node& node = *it;
     internal::WorkerPoolTask* task =
         static_cast<internal::WorkerPoolTask*>(node.task);
 
     if (!task->HasBeenScheduled()) {
       task->WillSchedule();
       task->ScheduleOnOriginThread(this);
       task->DidSchedule();
     }
   }
 
   task_graph_runner_->SetTaskGraph(namespace_token_, 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(
       &RasterWorkerPool::OnRasterFinished, weak_ptr_factory_.GetWeakPtr())));
 }
 
 scoped_refptr<internal::WorkerPoolTask>
 RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask(
     size_t tasks_required_for_activation_count) {
   return make_scoped_refptr(
       new RasterRequiredForActivationFinishedWorkerPoolTaskImpl(
           base::Bind(&RasterWorkerPool::OnRasterRequiredForActivationFinished,
                      weak_ptr_factory_.GetWeakPtr()),
           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");
 
   // Early out if current |raster_finished_task_| is not the source.
   if (source != raster_finished_task_.get())
     return;
 
   OnRasterTasksFinished();
 }
@@ skipping 20 matching lines @@
                       internal::TaskGraph::Node::TaskComparator(task)) ==
          graph->nodes.end());
   graph->nodes.push_back(
       internal::TaskGraph::Node(task, priority, dependencies));
 }
 
 // static
 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())
       continue;
 
     dependencies++;
 
     // Add decode task if it doesn't already exists in graph.
     internal::TaskGraph::Node::Vector::iterator decode_it =
         std::find_if(graph->nodes.begin(),
                      graph->nodes.end(),
                      internal::TaskGraph::Node::TaskComparator(decode_task));
     if (decode_it == graph->nodes.end())
       InsertNodeForTask(graph, decode_task, priority, 0u);
 
     graph->edges.push_back(internal::TaskGraph::Edge(decode_task, raster_task));
   }
 
   InsertNodeForTask(graph, raster_task, priority, dependencies);
 }
 
 }  // namespace cc