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 {
+    TRACE_EVENT0("cc", "RasterWorkerPoolTaskImpl::RunOnOriginThread");
+
+    Analyze(picture_pile_);

[vangelis, 2014/02/18 22:25:29]

I think the Analysis is an overkill for ganesh mode. With the high upload costs
removed, I think it's fine to live with the additional texture mem cost for the
rare cases where a tile is truly solid. 

+    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