cc: Reuse the same TaskGraph and completed tasks vector.

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 505 matching lines @@
   }
 }
 
 void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleMoreTasks");
 
   WorkerPoolTaskVector tasks;
   WorkerPoolTaskVector tasks_required_for_activation;
 
   unsigned priority = kRasterTaskPriorityBase;
-  internal::TaskGraph graph;
+
+  graph_.Reset();
 
   size_t bytes_pending_upload = bytes_pending_upload_;
   bool did_throttle_raster_tasks = false;
 
   for (RasterTaskVector::const_iterator it = raster_tasks().begin();
        it != raster_tasks().end();
        ++it) {
     internal::RasterWorkerPoolTask* task = it->get();
 
     // |raster_task_states_| contains the state of all tasks that we have not
@@ skipping 31 matching lines @@
       break;
     }
 
     // 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++);
+    InsertNodeForRasterTask(&graph_, task, task->dependencies(), priority++);
 
     tasks.container().push_back(task);
     if (IsRasterTaskRequiredForActivation(task))
       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());
   // Schedule OnRasterTasksRequiredForActivationFinished call only when
   // notification is pending and throttling is not preventing all pending
   // tasks required for activation from being scheduled.
   if (scheduled_raster_task_required_for_activation_count ==
           raster_tasks_required_for_activation_.size() &&
       should_notify_client_if_no_tasks_required_for_activation_are_pending_) {
     new_raster_required_for_activation_finished_task =
         CreateRasterRequiredForActivationFinishedTask(
             raster_tasks_required_for_activation_.size());
     raster_required_for_activation_finished_task_pending_ = true;
-    InsertNodeForTask(&graph,
+    InsertNodeForTask(&graph_,
                       new_raster_required_for_activation_finished_task.get(),
                       kRasterRequiredForActivationFinishedTaskPriority,
                       scheduled_raster_task_required_for_activation_count);
     for (WorkerPoolTaskVector::ContainerType::const_iterator it =
              tasks_required_for_activation.container().begin();
          it != tasks_required_for_activation.container().end();
          ++it) {
-      graph.edges.push_back(internal::TaskGraph::Edge(
+      graph_.edges.push_back(internal::TaskGraph::Edge(
           *it, new_raster_required_for_activation_finished_task.get()));
     }
   }
 
   scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task;
 
   size_t scheduled_raster_task_count = tasks.container().size();
   DCHECK_LE(scheduled_raster_task_count, PendingRasterTaskCount());
   // Schedule OnRasterTasksFinished call only when notification is pending
   // and throttling is not preventing all pending tasks from being scheduled.
   if (!did_throttle_raster_tasks &&
       should_notify_client_if_no_tasks_are_pending_) {
     new_raster_finished_task = CreateRasterFinishedTask();
     raster_finished_task_pending_ = true;
-    InsertNodeForTask(&graph,
+    InsertNodeForTask(&graph_,
                       new_raster_finished_task.get(),
                       kRasterFinishedTaskPriority,
                       scheduled_raster_task_count);
     for (WorkerPoolTaskVector::ContainerType::const_iterator it =
              tasks.container().begin();
          it != tasks.container().end();
          ++it) {
-      graph.edges.push_back(
+      graph_.edges.push_back(
           internal::TaskGraph::Edge(*it, new_raster_finished_task.get()));
     }
   }
 
-  SetTaskGraph(&graph);
+  SetTaskGraph(&graph_);
 
   scheduled_raster_task_count_ = scheduled_raster_task_count;
 
   set_raster_finished_task(new_raster_finished_task);
   set_raster_required_for_activation_finished_task(
       new_raster_required_for_activation_finished_task);
 }
 
 unsigned PixelBufferRasterWorkerPool::PendingRasterTaskCount() const {
   unsigned num_completed_raster_tasks =
@@ skipping 15 matching lines @@
     return "rasterizing";
   if (PendingRasterTaskCount())
     return "throttled";
   if (!raster_tasks_with_pending_upload_.empty())
     return "waiting_for_uploads";
 
   return "finishing";
 }
 
 void PixelBufferRasterWorkerPool::CheckForCompletedWorkerPoolTasks() {
-  internal::Task::Vector completed_tasks;
-  CollectCompletedWorkerPoolTasks(&completed_tasks);
-
-  for (internal::Task::Vector::const_iterator it = completed_tasks.begin();
-       it != completed_tasks.end();
+  CollectCompletedWorkerPoolTasks(&completed_tasks_);
+  for (internal::Task::Vector::const_iterator it = completed_tasks_.begin();
+       it != completed_tasks_.end();
        ++it) {
     internal::WorkerPoolTask* task =
         static_cast<internal::WorkerPoolTask*>(it->get());
 
     task->WillComplete();
     task->CompleteOnOriginThread(this);
     task->DidComplete();
   }
+  completed_tasks_.clear();
 }
 
 scoped_ptr<base::Value> PixelBufferRasterWorkerPool::StateAsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
 
   state->SetInteger("completed_count", completed_raster_tasks_.size());
   state->SetInteger("pending_count", raster_task_states_.size());
   state->SetInteger("pending_upload_count",
                     raster_tasks_with_pending_upload_.size());
   state->SetInteger("required_for_activation_count",
                     raster_tasks_required_for_activation_.size());
   state->Set("scheduled_state", ScheduledStateAsValue().release());
   state->Set("throttle_state", ThrottleStateAsValue().release());
   return state.PassAs<base::Value>();
 }
 
 scoped_ptr<base::Value> PixelBufferRasterWorkerPool::ThrottleStateAsValue()
     const {
   scoped_ptr<base::DictionaryValue> throttle_state(new base::DictionaryValue);
 
   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