cc: Remove RasterWorkerPool::Task.

cc/resources/pixel_buffer_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/pixel_buffer_raster_worker_pool.h"
 
 #include "base/containers/stack_container.h"
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/debug/traced_value.h"
@@ skipping 70 matching lines @@
 
     // All unscheduled tasks need to be canceled.
     if (it->second == UNSCHEDULED) {
       completed_raster_tasks_.push_back(task);
       it->second = COMPLETED;
     }
   }
   DCHECK_EQ(completed_raster_tasks_.size(), raster_task_states_.size());
 }
 
-void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
+void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::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 (!should_notify_client_if_no_tasks_are_pending_)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
 
   should_notify_client_if_no_tasks_are_pending_ = true;
   should_notify_client_if_no_tasks_required_for_activation_are_pending_ = true;
 
   raster_tasks_required_for_activation_.clear();
 
   // Build new raster task state map.
   RasterTaskStateMap new_raster_task_states;
-  for (RasterTaskQueueIterator it(queue); it; ++it) {
-    internal::RasterWorkerPoolTask* task = *it;
+  for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
+       it != queue->items.end();
+       ++it) {
+    const RasterTaskQueue::Item& item = *it;
+    internal::RasterWorkerPoolTask* task = item.task;
     DCHECK(new_raster_task_states.find(task) == new_raster_task_states.end());
 
     RasterTaskStateMap::iterator state_it = raster_task_states_.find(task);
     if (state_it != raster_task_states_.end()) {
       RasterTaskState state = state_it->second;
 
       new_raster_task_states[task] = state;
       // |raster_tasks_required_for_activation_| contains all tasks that need to
       // complete before we can send a "ready to activate" signal. Tasks that
       // have already completed should not be part of this set.
-      if (state != COMPLETED && it.required_for_activation())
+      if (state != COMPLETED && item.required_for_activation)
         raster_tasks_required_for_activation_.insert(task);
 
       raster_task_states_.erase(state_it);
     } else {
       DCHECK(!task->HasBeenScheduled());
       new_raster_task_states[task] = UNSCHEDULED;
-      if (it.required_for_activation())
+      if (item.required_for_activation)
         raster_tasks_required_for_activation_.insert(task);
     }
   }
 
   // Transfer old raster task state to |new_raster_task_states| and cancel all
   // remaining unscheduled tasks.
   for (RasterTaskStateMap::iterator it = raster_task_states_.begin();
        it != raster_task_states_.end();
        ++it) {
     internal::RasterWorkerPoolTask* task = it->first;
@@ skipping 101 matching lines @@
   // Balanced with MapPixelRasterBuffer() call in AcquireCanvasForRaster().
   resource_provider()->UnmapPixelRasterBuffer(task->resource()->id());
 
   if (!task->HasFinishedRunning() || analysis.is_solid_color) {
     resource_provider()->ReleasePixelRasterBuffer(task->resource()->id());
 
     if (!task->HasFinishedRunning()) {
       // When priorites change, a raster task can be canceled as a result of
       // no longer being of high enough priority to fit in our throttled
       // raster task budget. The task has not yet completed in this case.
-      for (RasterTaskQueueIterator it(&raster_tasks_); it; ++it) {
-        if (*it == task) {
+      for (RasterTaskQueue::Item::Vector::const_iterator it =
+               raster_tasks_.items.begin();
+           it != raster_tasks_.items.end();
+           ++it) {
+        if (it->task == task) {
           raster_task_states_[task] = UNSCHEDULED;
           return;
         }
       }
     }
 
     DCHECK(std::find(completed_raster_tasks_.begin(),
                      completed_raster_tasks_.end(),
                      task) == completed_raster_tasks_.end());
     completed_raster_tasks_.push_back(task);
@@ skipping 234 matching lines @@
   WorkerPoolTaskVector tasks;
   WorkerPoolTaskVector tasks_required_for_activation;
 
   unsigned priority = kRasterTaskPriorityBase;
 
   graph_.Reset();
 
   size_t bytes_pending_upload = bytes_pending_upload_;
   bool did_throttle_raster_tasks = false;
 
-  for (RasterTaskQueueIterator it(&raster_tasks_); it; ++it) {
-    internal::RasterWorkerPoolTask* task = *it;
+  for (RasterTaskQueue::Item::Vector::const_iterator it =
+           raster_tasks_.items.begin();
+       it != raster_tasks_.items.end();
+       ++it) {
+    const RasterTaskQueue::Item& item = *it;
+    internal::RasterWorkerPoolTask* task = item.task;
 
     // |raster_task_states_| contains the state of all tasks that we have not
     // yet run reply callbacks for.
     RasterTaskStateMap::iterator state_it = raster_task_states_.find(task);
     if (state_it == raster_task_states_.end())
       continue;
 
     // Skip task if completed.
     if (state_it->second == COMPLETED) {
       DCHECK(std::find(completed_raster_tasks_.begin(),
@@ skipping 26 matching lines @@
     // Update |bytes_pending_upload| now that task has cleared all
     // throttling limits.
     bytes_pending_upload = new_bytes_pending_upload;
 
     DCHECK(state_it->second == UNSCHEDULED || state_it->second == SCHEDULED);
     state_it->second = SCHEDULED;
 
     InsertNodeForRasterTask(&graph_, task, task->dependencies(), priority++);
 
     tasks.container().push_back(task);
-    if (it.required_for_activation())
+    if (item.required_for_activation)
       tasks_required_for_activation.container().push_back(task);
   }
 
   scoped_refptr<internal::WorkerPoolTask>
       new_raster_required_for_activation_finished_task;
 
   size_t scheduled_raster_task_required_for_activation_count =
       tasks_required_for_activation.container().size();
   DCHECK_LE(scheduled_raster_task_required_for_activation_count,
             raster_tasks_required_for_activation_.size());
@@ skipping 118 matching lines @@
 
   throttle_state->SetInteger("bytes_available_for_upload",
                              max_bytes_pending_upload_ - bytes_pending_upload_);
   throttle_state->SetInteger("bytes_pending_upload", bytes_pending_upload_);
   throttle_state->SetInteger("scheduled_raster_task_count",
                              scheduled_raster_task_count_);
   return throttle_state.PassAs<base::Value>();
 }
 
 }  // namespace cc