cc: Separate RasterWorkerPool interface from implementation details.

cc/resources/direct_raster_worker_pool.cc

 // Copyright 2014 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/direct_raster_worker_pool.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/output/context_provider.h"
 #include "cc/resources/resource.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 
 namespace cc {
 
 // static
-scoped_ptr<DirectRasterWorkerPool> DirectRasterWorkerPool::Create(
+scoped_ptr<RasterWorkerPool> DirectRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     ResourceProvider* resource_provider,
     ContextProvider* context_provider) {
-  return make_scoped_ptr(new DirectRasterWorkerPool(
+  return make_scoped_ptr<RasterWorkerPool>(new DirectRasterWorkerPool(
       task_runner, resource_provider, context_provider));
 }
 
 DirectRasterWorkerPool::DirectRasterWorkerPool(
     base::SequencedTaskRunner* task_runner,
     ResourceProvider* resource_provider,
     ContextProvider* context_provider)
     : task_runner_(task_runner),
       resource_provider_(resource_provider),
       context_provider_(context_provider),
       run_tasks_on_origin_thread_pending_(false),
       raster_tasks_pending_(false),
       raster_tasks_required_for_activation_pending_(false),
       raster_finished_weak_ptr_factory_(this),
       weak_ptr_factory_(this) {}
 
 DirectRasterWorkerPool::~DirectRasterWorkerPool() {
   DCHECK_EQ(0u, completed_tasks_.size());
 }
 
-void DirectRasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
+Rasterizer* DirectRasterWorkerPool::AsRasterizer() { return this; }
+
+void DirectRasterWorkerPool::SetClient(RasterizerClient* client) {
   client_ = client;
 }
 
 void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   TRACE_EVENT0("cc", "DirectRasterWorkerPool::ScheduleTasks");
 
   DCHECK_EQ(queue->required_for_activation_count,
             static_cast<size_t>(
                 std::count_if(queue->items.begin(),
                               queue->items.end(),
                               RasterTaskQueue::Item::IsRequiredForActivation)));
 
   raster_tasks_pending_ = true;
   raster_tasks_required_for_activation_pending_ = true;
 
   // Cancel existing OnRasterFinished callbacks.
   raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
-  scoped_refptr<internal::WorkerPoolTask>
+  scoped_refptr<internal::RasterizerTask>
       new_raster_required_for_activation_finished_task(
           CreateRasterRequiredForActivationFinishedTask(
               queue->required_for_activation_count,
               task_runner_.get(),
               base::Bind(&DirectRasterWorkerPool::
                              OnRasterRequiredForActivationFinished,
                          raster_finished_weak_ptr_factory_.GetWeakPtr())));
-  scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
+  scoped_refptr<internal::RasterizerTask> new_raster_finished_task(
       CreateRasterFinishedTask(
           task_runner_.get(),
           base::Bind(&DirectRasterWorkerPool::OnRasterFinished,
                      raster_finished_weak_ptr_factory_.GetWeakPtr())));
 
   // Need to cancel tasks not present in new queue if we haven't had a
   // chance to run the previous set of tasks yet.
   // TODO(reveman): Remove this once only tasks for which
   // ::ScheduleOnOriginThread has been called need to be canceled.
   if (run_tasks_on_origin_thread_pending_) {
     for (RasterTaskQueue::Item::Vector::const_iterator it =
              raster_tasks_.items.begin();
          it != raster_tasks_.items.end();
          ++it) {
-      internal::RasterWorkerPoolTask* task = it->task;
+      internal::RasterTask* task = it->task;
 
       if (std::find_if(queue->items.begin(),
                        queue->items.end(),
                        RasterTaskQueue::Item::TaskComparator(task)) ==
           queue->items.end())
         completed_tasks_.push_back(task);
     }
   }
 
   ScheduleRunTasksOnOriginThread();
 
   raster_tasks_.Swap(queue);
 
   raster_finished_task_ = new_raster_finished_task;
   raster_required_for_activation_finished_task_ =
       new_raster_required_for_activation_finished_task;
 }
 
 unsigned DirectRasterWorkerPool::GetResourceTarget() const {
   return GL_TEXTURE_2D;
 }
 
 ResourceFormat DirectRasterWorkerPool::GetResourceFormat() const {
   return resource_provider_->best_texture_format();
 }
 
 void DirectRasterWorkerPool::CheckForCompletedTasks() {
   TRACE_EVENT0("cc", "DirectRasterWorkerPool::CheckForCompletedTasks");
 
-  for (internal::WorkerPoolTask::Vector::const_iterator it =
+  for (internal::RasterizerTask::Vector::const_iterator it =
            completed_tasks_.begin();
        it != completed_tasks_.end();
        ++it) {
-    internal::WorkerPoolTask* task = it->get();
+    internal::RasterizerTask* task = it->get();
 
     task->RunReplyOnOriginThread();
   }
   completed_tasks_.clear();
 }
 
 SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster(
-    internal::WorkerPoolTask* task,
-    const Resource* resource) {
-  return resource_provider_->MapDirectRasterBuffer(resource->id());
+    internal::RasterTask* task) {
+  return resource_provider_->MapDirectRasterBuffer(task->resource()->id());
 }
 
 void DirectRasterWorkerPool::ReleaseCanvasForRaster(
-    internal::WorkerPoolTask* task,
-    const Resource* resource) {
-  resource_provider_->UnmapDirectRasterBuffer(resource->id());
+    internal::RasterTask* task) {
+  resource_provider_->UnmapDirectRasterBuffer(task->resource()->id());
 }
 
 void DirectRasterWorkerPool::OnRasterFinished() {
   TRACE_EVENT0("cc", "DirectRasterWorkerPool::OnRasterFinished");
 
   DCHECK(raster_tasks_pending_);
   raster_tasks_pending_ = false;
   client_->DidFinishRunningTasks();
 }
 
@@ skipping 34 matching lines @@
 
     GrContext* gr_context = context_provider_->GrContext();
     // TODO(alokp): Implement TestContextProvider::GrContext().
     if (gr_context)
       gr_context->resetContext();
 
     for (RasterTaskQueue::Item::Vector::const_iterator it =
              raster_tasks_.items.begin();
          it != raster_tasks_.items.end();
          ++it) {
-      internal::RasterWorkerPoolTask* task = it->task;
+      internal::RasterTask* task = it->task;
       DCHECK(!task->HasCompleted());
 
       // First need to run all dependencies.
-      for (internal::WorkerPoolTask::Vector::const_iterator it =
+      for (internal::ImageDecodeTask::Vector::const_iterator it =
                task->dependencies().begin();
            it != task->dependencies().end();
            ++it) {
-        internal::WorkerPoolTask* dependency = it->get();
+        internal::ImageDecodeTask* dependency = it->get();
         if (dependency->HasCompleted())
           continue;
 
         RunTaskOnOriginThread(dependency);
         completed_tasks_.push_back(dependency);
       }
 
       RunTaskOnOriginThread(task);
       completed_tasks_.push_back(task);
     }
 
     // TODO(alokp): Implement TestContextProvider::GrContext().
     if (gr_context)
       gr_context->flush();
 
     context_provider_->ContextGL()->PopGroupMarkerEXT();
   }
 
   RunTaskOnOriginThread(raster_required_for_activation_finished_task_.get());
   RunTaskOnOriginThread(raster_finished_task_.get());
 }
 
 void DirectRasterWorkerPool::RunTaskOnOriginThread(
-    internal::WorkerPoolTask* task) {
+    internal::RasterizerTask* task) {
   task->WillSchedule();
   task->ScheduleOnOriginThread(this);
   task->DidSchedule();
 
   task->WillRun();
   task->RunOnOriginThread();
   task->DidRun();
 
   task->WillComplete();
   task->CompleteOnOriginThread(this);
   task->DidComplete();
 }
 
 }  // namespace cc