cc: Renaming Rasterizer and RasterWorkerPool interfaces

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 ca951f62f9339b5b0d91a0186c6e90d5b7fa864c..7e3b7487adad61536818b0f5a3ca6474ccd84e55 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -23,7 +23,7 @@ class RasterTaskGraphRunner : public TaskGraphRunner,
                               public base::DelegateSimpleThread::Delegate {
  public:
   RasterTaskGraphRunner() {
-    size_t num_threads = RasterWorkerPool::GetNumRasterThreads();
+    size_t num_threads = TileTaskWorkerPool::GetNumRasterThreads();
     while (workers_.size() < num_threads) {
       scoped_ptr<base::DelegateSimpleThread> worker =
           make_scoped_ptr(new base::DelegateSimpleThread(
@@ -55,7 +55,7 @@ const int kDefaultNumRasterThreads = 1;
 
 int g_num_raster_threads = 0;
 
-class RasterFinishedTaskImpl : public RasterizerTask {
+class RasterFinishedTaskImpl : public TileTask {
  public:
   explicit RasterFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
@@ -69,9 +69,9 @@ class RasterFinishedTaskImpl : public RasterizerTask {
     RasterFinished();
   }
 
-  // Overridden from RasterizerTask:
-  void ScheduleOnOriginThread(RasterizerTaskClient* client) override {}
-  void CompleteOnOriginThread(RasterizerTaskClient* client) override {}
+  // Overridden from TileTask:
+  void ScheduleOnOriginThread(TileTaskClient* client) override {}
+  void CompleteOnOriginThread(TileTaskClient* client) override {}
   void RunReplyOnOriginThread() override {}
 
  protected:
@@ -92,18 +92,20 @@ class RasterFinishedTaskImpl : public RasterizerTask {
 
 // This allows a micro benchmark system to run tasks with highest priority,
 // since it should finish as quickly as possible.
-unsigned RasterWorkerPool::kBenchmarkRasterTaskPriority = 0u;
+unsigned TileTaskWorkerPool::kBenchmarkTaskPriority = 0u;
 // Task priorities that make sure raster finished tasks run before any
 // remaining raster tasks.
-unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 1u;
-unsigned RasterWorkerPool::kRasterTaskPriorityBase = 2u;
+unsigned TileTaskWorkerPool::kTaskSetFinishedTaskPriority = 1u;
+unsigned TileTaskWorkerPool::kTileTaskPriorityBase = 2u;
 
-RasterWorkerPool::RasterWorkerPool() {}
+TileTaskWorkerPool::TileTaskWorkerPool() {
+}
 
-RasterWorkerPool::~RasterWorkerPool() {}
+TileTaskWorkerPool::~TileTaskWorkerPool() {
+}
 
 // static
-void RasterWorkerPool::SetNumRasterThreads(int num_threads) {
+void TileTaskWorkerPool::SetNumRasterThreads(int num_threads) {
   DCHECK_LT(0, num_threads);
   DCHECK_EQ(0, g_num_raster_threads);
 
@@ -111,7 +113,7 @@ void RasterWorkerPool::SetNumRasterThreads(int num_threads) {
 }
 
 // static
-int RasterWorkerPool::GetNumRasterThreads() {
+int TileTaskWorkerPool::GetNumRasterThreads() {
   if (!g_num_raster_threads)
     g_num_raster_threads = kDefaultNumRasterThreads;
 
@@ -119,12 +121,12 @@ int RasterWorkerPool::GetNumRasterThreads() {
 }
 
 // static
-TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
+TaskGraphRunner* TileTaskWorkerPool::GetTaskGraphRunner() {
   return g_task_graph_runner.Pointer();
 }
 
 // static
-scoped_refptr<RasterizerTask> RasterWorkerPool::CreateRasterFinishedTask(
+scoped_refptr<TileTask> TileTaskWorkerPool::CreateTaskSetFinishedTask(
     base::SequencedTaskRunner* task_runner,
     const base::Closure& on_raster_finished_callback) {
   return make_scoped_refptr(
@@ -132,15 +134,15 @@ scoped_refptr<RasterizerTask> RasterWorkerPool::CreateRasterFinishedTask(
 }
 
 // static
-void RasterWorkerPool::ScheduleTasksOnOriginThread(RasterizerTaskClient* client,
-                                                   TaskGraph* graph) {
-  TRACE_EVENT0("cc", "Rasterizer::ScheduleTasksOnOriginThread");
+void TileTaskWorkerPool::ScheduleTasksOnOriginThread(TileTaskClient* client,
+                                                     TaskGraph* graph) {
+  TRACE_EVENT0("cc", "TileTaskWorkerPool::ScheduleTasksOnOriginThread");
 
   for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
        it != graph->nodes.end();
        ++it) {
     TaskGraph::Node& node = *it;
-    RasterizerTask* task = static_cast<RasterizerTask*>(node.task);
+    TileTask* task = static_cast<TileTask*>(node.task);
 
     if (!task->HasBeenScheduled()) {
       task->WillSchedule();
@@ -151,10 +153,10 @@ void RasterWorkerPool::ScheduleTasksOnOriginThread(RasterizerTaskClient* client,
 }
 
 // static
-void RasterWorkerPool::InsertNodeForTask(TaskGraph* graph,
-                                         RasterizerTask* task,
-                                         unsigned priority,
-                                         size_t dependencies) {
+void TileTaskWorkerPool::InsertNodeForTask(TaskGraph* graph,
+                                           TileTask* task,
+                                           unsigned priority,
+                                           size_t dependencies) {
   DCHECK(std::find_if(graph->nodes.begin(),
                       graph->nodes.end(),
                       TaskGraph::Node::TaskComparator(task)) ==
@@ -163,7 +165,7 @@ void RasterWorkerPool::InsertNodeForTask(TaskGraph* graph,
 }
 
 // static
-void RasterWorkerPool::InsertNodesForRasterTask(
+void TileTaskWorkerPool::InsertNodesForRasterTask(
     TaskGraph* graph,
     RasterTask* raster_task,
     const ImageDecodeTask::Vector& decode_tasks,
@@ -214,13 +216,13 @@ static bool IsSupportedPlaybackToMemoryFormat(ResourceFormat format) {
 }
 
 // static
-void RasterWorkerPool::PlaybackToMemory(void* memory,
-                                        ResourceFormat format,
-                                        const gfx::Size& size,
-                                        int stride,
-                                        const RasterSource* raster_source,
-                                        const gfx::Rect& rect,
-                                        float scale) {
+void TileTaskWorkerPool::PlaybackToMemory(void* memory,
+                                          ResourceFormat format,
+                                          const gfx::Size& size,
+                                          int stride,
+                                          const RasterSource* raster_source,
+                                          const gfx::Rect& rect,
+                                          float scale) {
   DCHECK(IsSupportedPlaybackToMemoryFormat(format)) << format;
 
   // Uses kPremul_SkAlphaType since the result is not known to be opaque.