Handle out of order tile priorities when building graph

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 177 matching lines @@
 
     dependencies++;
 
     // Add decode task if it doesn't already exists in graph.
     TaskGraph::Node::Vector::iterator decode_it =
         std::find_if(graph->nodes.begin(), graph->nodes.end(),
                      [decode_task](const TaskGraph::Node& node) {
                        return node.task == decode_task;
                      });
 
-    // Tasks are inserted in priority order, so existing decode tasks should
-    // already be FOREGROUND if this is a high priority task.
-    DCHECK(decode_it == graph->nodes.end() || !high_priority ||
-           static_cast<uint16_t>(TASK_CATEGORY_FOREGROUND) ==
-               decode_it->category);
+    // In rare circumstances, a low priority task may come in before a high
+    // 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 != static_cast<uint16_t>(decode_task_category)) {

[vmpstr, 2016/03/21 19:44:50]

Why is static_cast required here? (and not below?)

[ericrk, 2016/03/24 17:56:04]

I guess it's not... I must not have checked :D

+      decode_it->category = decode_task_category;
+    }
 
     if (decode_it == graph->nodes.end()) {
       InsertNodeForTask(graph, decode_task, decode_task_category, priority, 0u);
     }
 
     graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
   }
 
   InsertNodeForTask(graph, raster_task, raster_task_category, priority,
                     dependencies);
@@ skipping 548 matching lines @@
           TaskGraph::Edge(task, required_for_activation_done_task.get()));
     }
     if (tile->required_for_draw()) {
       required_for_draw_count++;
       graph_.edges.push_back(
           TaskGraph::Edge(task, required_for_draw_done_task.get()));
     }
     all_count++;
     graph_.edges.push_back(TaskGraph::Edge(task, all_done_task.get()));
 
+    // A tile is high priority if it is either blocking future compositing
+    // (requierd for draw or required for activation), or if it has a priority

[vmpstr, 2016/03/21 19:44:51]

s/requierd/required/

[ericrk, 2016/03/24 17:56:04]

Done.

+    // bin of NOW for another reason (low resolution tiles).
     bool high_priority =
-        tile->required_for_draw() || tile->required_for_activation();
+        tile->required_for_draw() || tile->required_for_activation() ||
+        prioritized_tile.priority().priority_bin == TilePriority::NOW;
     InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++,
                              use_gpu_rasterization_, high_priority);
   }
 
   // Insert nodes for our task completion tasks. We enqueue these using
   // FOREGROUND priority as they are relatively quick tasks and we'd like
   // to trigger our callbacks quickly to aid in scheduling.
   InsertNodeForTask(&graph_, required_for_activation_done_task.get(),
                     TASK_CATEGORY_FOREGROUND,
                     kRequiredForActivationDoneTaskPriority,
@@ skipping 410 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