cc: Switch to vector based TaskGraph implementation.

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"
 #include "cc/resources/resource.h"
-#include "third_party/skia/include/core/SkBitmapDevice.h"
-
-#if defined(OS_ANDROID)
-#include "base/android/sys_utils.h"
-#endif
 
 namespace cc {
 namespace {
 
 const int kCheckForCompletedRasterTasksDelayMs = 6;
 
 const size_t kMaxScheduledRasterTasks = 48;
 
-typedef base::StackVector<internal::GraphNode*, kMaxScheduledRasterTasks>
-    NodeVector;
-
-void AddDependenciesToGraphNode(internal::GraphNode* node,
-                                const NodeVector::ContainerType& dependencies) {
-  for (NodeVector::ContainerType::const_iterator it = dependencies.begin();
-       it != dependencies.end();
-       ++it) {
-    internal::GraphNode* dependency = *it;
-
-    node->add_dependency();
-    dependency->add_dependent(node);
-  }
-}
+typedef base::StackVector<internal::WorkerPoolTask*, kMaxScheduledRasterTasks>
+    WorkerPoolTaskVector;
 
 // Only used as std::find_if predicate for DCHECKs.
 bool WasCanceled(const internal::RasterWorkerPoolTask* task) {
   return !task->HasFinishedRunning();
 }
 
 }  // namespace
 
 PixelBufferRasterWorkerPool::PixelBufferRasterWorkerPool(
     ResourceProvider* resource_provider,
@@ skipping 430 matching lines @@
   if (will_notify_client_that_no_tasks_are_pending) {
     TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
     DCHECK(!HasPendingTasksRequiredForActivation());
     client()->DidFinishRunningTasks();
   }
 }
 
 void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleMoreTasks");
 
-  enum RasterTaskType {
-    PREPAINT_TYPE = 0,
-    REQUIRED_FOR_ACTIVATION_TYPE = 1,
-    NUM_TYPES = 2
-  };
-  NodeVector tasks[NUM_TYPES];
-  unsigned priority = 2u;  // 0-1 reserved for RasterFinished tasks.
-  TaskGraph graph;
+  WorkerPoolTaskVector tasks;
+  WorkerPoolTaskVector tasks_required_for_activation;
+
+  unsigned priority = kRasterTaskPriorityBase;
+  internal::TaskGraph graph;
 
   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 19 matching lines @@
     }
 
     // If raster has finished, just update |bytes_pending_upload|.
     if (state_it->second == UPLOADING) {
       DCHECK(task->HasCompleted());
       bytes_pending_upload = new_bytes_pending_upload;
       continue;
     }
 
     // Throttle raster tasks based on kMaxScheduledRasterTasks.
-    size_t scheduled_raster_task_count =
-        tasks[PREPAINT_TYPE].container().size() +
-        tasks[REQUIRED_FOR_ACTIVATION_TYPE].container().size();
-    if (scheduled_raster_task_count >= kMaxScheduledRasterTasks) {
+    if (tasks.container().size() >= kMaxScheduledRasterTasks) {
       did_throttle_raster_tasks = true;
       break;
     }
 
     // Update |bytes_pending_upload| now that task has cleared all
     // throttling limits.
     bytes_pending_upload = new_bytes_pending_upload;
 
-    RasterTaskType type = IsRasterTaskRequiredForActivation(task)
-                              ? REQUIRED_FOR_ACTIVATION_TYPE
-                              : PREPAINT_TYPE;
-
     DCHECK(state_it->second == UNSCHEDULED || state_it->second == SCHEDULED);
     state_it->second = SCHEDULED;
 
-    tasks[type].container().push_back(CreateGraphNodeForRasterTask(
-        task, task->dependencies(), priority++, &graph));
+    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_TYPE].container().size();
+      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;
-    internal::GraphNode* raster_required_for_activation_finished_node =
-        CreateGraphNodeForTask(
-            new_raster_required_for_activation_finished_task.get(),
-            0u,  // Priority 0
-            &graph);
-    AddDependenciesToGraphNode(raster_required_for_activation_finished_node,
-                               tasks[REQUIRED_FOR_ACTIVATION_TYPE].container());
+    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(
+          *it, new_raster_required_for_activation_finished_task.get()));
+    }
   }
 
   scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task;
 
-  size_t scheduled_raster_task_count =
-      tasks[PREPAINT_TYPE].container().size() +
-      tasks[REQUIRED_FOR_ACTIVATION_TYPE].container().size();
+  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;
-    internal::GraphNode* raster_finished_node =
-        CreateGraphNodeForTask(new_raster_finished_task.get(),
-                               1u,  // Priority 1
-                               &graph);
-    for (unsigned type = 0; type < NUM_TYPES; ++type) {
-      AddDependenciesToGraphNode(raster_finished_node, tasks[type].container());
+    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(
+          internal::TaskGraph::Edge(*it, new_raster_finished_task.get()));
     }
   }
 
   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);
@@ skipping 61 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