Gpu Image Decode Controller

cc/tiles/tile_manager.cc

 // Copyright 2012 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/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 136 matching lines @@
                        uint16_t priority,
                        size_t dependencies) {
   DCHECK(std::find_if(graph->nodes.begin(), graph->nodes.end(),
                       [task](const TaskGraph::Node& node) {
                         return node.task == task;
                       }) == graph->nodes.end());
   graph->nodes.push_back(
       TaskGraph::Node(task, category, priority, dependencies));
 }
 
+void InsertNodeForDecodeTask(TaskGraph* graph,
+                             ImageDecodeTask* task,
+                             uint16_t category,
+                             uint16_t priority) {
+  uint32_t dependency_count = 0u;
+  auto* dependency = task->dependency().get();
+  if (dependency && !dependency->HasCompleted()) {
+    InsertNodeForDecodeTask(graph, dependency, category, priority);
+    graph->edges.push_back(TaskGraph::Edge(dependency, task));
+    dependency_count = 1u;
+  }
+  InsertNodeForTask(graph, task, task->SupportsConcurrentExecution()
+                                     ? category
+                                     : TASK_CATEGORY_NONCONCURRENT_FOREGROUND,
+                    priority, dependency_count);
+}
+
 void InsertNodesForRasterTask(TaskGraph* graph,
                               RasterTask* raster_task,
                               const ImageDecodeTask::Vector& decode_tasks,
                               size_t priority,
                               bool use_gpu_rasterization,
                               bool high_priority) {
   size_t dependencies = 0u;
 
   // Determine the TaskCategory for raster tasks - if a task uses GPU, it
   // cannot run concurrently and is assigned
@@ skipping 34 matching lines @@
     // priority task. In these cases, upgrade any low-priority dependencies of
     // the current task.
     // TODO(ericrk): Task iterators should be updated to avoid this.
     // crbug.com/594851
     if (decode_it != graph->nodes.end() && high_priority &&
         decode_it->category != decode_task_category) {
       decode_it->category = decode_task_category;
     }
 
     if (decode_it == graph->nodes.end()) {
-      InsertNodeForTask(graph, decode_task, decode_task_category, priority, 0u);
+      InsertNodeForDecodeTask(graph, decode_task, decode_task_category,
+                              priority);
     }
 
     graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
   }
 
   InsertNodeForTask(graph, raster_task, raster_task_category, priority,
                     dependencies);
 }
 
 class TaskSetFinishedTaskImpl : public TileTask {
@@ skipping 990 matching lines @@
 void TileManager::Signals::reset() {
   ready_to_activate = false;
   did_notify_ready_to_activate = false;
   ready_to_draw = false;
   did_notify_ready_to_draw = false;
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 }  // namespace cc