cc: Remove RasterWorkerPool::Task.

cc/resources/image_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/image_raster_worker_pool.h"
 
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/resource.h"
@@ skipping 15 matching lines @@
     internal::TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
     unsigned texture_target)
     : RasterWorkerPool(task_graph_runner, resource_provider),
       texture_target_(texture_target),
       raster_tasks_pending_(false),
       raster_tasks_required_for_activation_pending_(false) {}
 
 ImageRasterWorkerPool::~ImageRasterWorkerPool() {}
 
-void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
+void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   TRACE_EVENT0("cc", "ImageRasterWorkerPool::ScheduleTasks");
 
+  DCHECK_EQ(queue->required_for_activation_count,
+            static_cast<size_t>(
+                std::count_if(queue->items.begin(),
+                              queue->items.end(),
+                              RasterTaskQueue::Item::IsRequiredForActivation)));
+
   if (!raster_tasks_pending_)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
 
   raster_tasks_pending_ = true;
   raster_tasks_required_for_activation_pending_ = true;
 
   unsigned priority = kRasterTaskPriorityBase;
 
   graph_.Reset();
 
   scoped_refptr<internal::WorkerPoolTask>
       new_raster_required_for_activation_finished_task(
           CreateRasterRequiredForActivationFinishedTask(
-              queue->required_for_activation_count()));
+              queue->required_for_activation_count));
   scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
       CreateRasterFinishedTask());
 
   for (RasterTaskQueueIterator it(queue); it; ++it) {
     internal::RasterWorkerPoolTask* task = *it;
     DCHECK(!task->HasCompleted());
 
     if (it.required_for_activation()) {
       graph_.edges.push_back(internal::TaskGraph::Edge(
           task, new_raster_required_for_activation_finished_task.get()));
     }
 
     InsertNodeForRasterTask(&graph_, task, task->dependencies(), priority++);
 
     graph_.edges.push_back(
         internal::TaskGraph::Edge(task, new_raster_finished_task.get()));
   }
 
   InsertNodeForTask(&graph_,
                     new_raster_required_for_activation_finished_task.get(),
                     kRasterRequiredForActivationFinishedTaskPriority,
-                    queue->required_for_activation_count());
+                    queue->required_for_activation_count);
   InsertNodeForTask(&graph_,
                     new_raster_finished_task.get(),
                     kRasterFinishedTaskPriority,
-                    queue->count());
+                    queue->items.size());
 
   raster_tasks_.Swap(queue);
 
   SetTaskGraph(&graph_);
 
   set_raster_finished_task(new_raster_finished_task);
   set_raster_required_for_activation_finished_task(
       new_raster_required_for_activation_finished_task);
 
   TRACE_EVENT_ASYNC_STEP_INTO1(
@@ skipping 65 matching lines @@
 
 scoped_ptr<base::Value> ImageRasterWorkerPool::StateAsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
 
   state->SetBoolean("tasks_required_for_activation_pending",
                     raster_tasks_required_for_activation_pending_);
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc