cc: Remove cc:RasterRequiredForActivation synthetic delays.

cc/resources/image_copy_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/image_copy_raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
@@ skipping 52 matching lines @@
   TRACE_EVENT0("cc", "ImageCopyRasterWorkerPool::Shutdown");
 
   TaskGraph empty;
   task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
   task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
 }
 
 void ImageCopyRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   TRACE_EVENT0("cc", "ImageCopyRasterWorkerPool::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();
 
   // Cancel existing OnRasterFinished callbacks.
   raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
   scoped_refptr<RasterizerTask>
-      new_raster_required_for_activation_finished_task(
-          CreateRasterRequiredForActivationFinishedTask(
-              queue->required_for_activation_count,
-              task_runner_.get(),
-              base::Bind(&ImageCopyRasterWorkerPool::
-                             OnRasterRequiredForActivationFinished,
-                         raster_finished_weak_ptr_factory_.GetWeakPtr())));
+      new_raster_required_for_activation_finished_task(CreateRasterFinishedTask(
+          task_runner_.get(),
+          base::Bind(
+              &ImageCopyRasterWorkerPool::OnRasterRequiredForActivationFinished,
+              raster_finished_weak_ptr_factory_.GetWeakPtr())));
   scoped_refptr<RasterizerTask> new_raster_finished_task(
       CreateRasterFinishedTask(
           task_runner_.get(),
           base::Bind(&ImageCopyRasterWorkerPool::OnRasterFinished,
                      raster_finished_weak_ptr_factory_.GetWeakPtr())));
 
   resource_pool_->CheckBusyResources();
 
+  size_t required_for_activation_count = 0;
+
   for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
        it != queue->items.end();
        ++it) {
     const RasterTaskQueue::Item& item = *it;
     RasterTask* task = item.task;
     DCHECK(!task->HasCompleted());
 
     if (item.required_for_activation) {
+      ++required_for_activation_count;
       graph_.edges.push_back(TaskGraph::Edge(
           task, new_raster_required_for_activation_finished_task.get()));
     }
 
     InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
 
     graph_.edges.push_back(
         TaskGraph::Edge(task, new_raster_finished_task.get()));
   }
 
   InsertNodeForTask(&graph_,
                     new_raster_required_for_activation_finished_task.get(),
                     kRasterRequiredForActivationFinishedTaskPriority,
-                    queue->required_for_activation_count);
+                    required_for_activation_count);
   InsertNodeForTask(&graph_,
                     new_raster_finished_task.get(),
                     kRasterFinishedTaskPriority,
                     queue->items.size());
 
   ScheduleTasksOnOriginThread(this, &graph_);
   task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
 
   raster_finished_task_ = new_raster_finished_task;
   raster_required_for_activation_finished_task_ =
@@ skipping 115 matching lines @@
                             resource_pool_->total_memory_usage_bytes());
   staging_state->SetInteger("pending_copy_count",
                             resource_pool_->total_resource_count() -
                                 resource_pool_->acquired_resource_count());
   staging_state->SetInteger("bytes_pending_copy",
                             resource_pool_->total_memory_usage_bytes() -
                                 resource_pool_->acquired_memory_usage_bytes());
 }
 
 }  // namespace cc