cc: Add a flag to check for tile priority inversion in AssignGpuMemory.

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 327 matching lines @@
   state->SetInteger("completed_count",
                     base::saturated_cast<int>(stats.completed_count));
   state->SetInteger("canceled_count",
                     base::saturated_cast<int>(stats.canceled_count));
   return std::move(state);
 }
 
 TileManager::TileManager(TileManagerClient* client,
                          base::SequencedTaskRunner* task_runner,
                          size_t scheduled_raster_task_limit,
-                         bool use_partial_raster)
+                         bool use_partial_raster,
+                         bool check_tile_priority_inversion)
     : client_(client),
       task_runner_(task_runner),
       resource_pool_(nullptr),
       tile_task_manager_(nullptr),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       use_partial_raster_(use_partial_raster),
       use_gpu_rasterization_(false),
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       did_oom_on_last_assign_(false),
       more_tiles_need_prepare_check_notifier_(
           task_runner_,
           base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
                      base::Unretained(this))),
       signals_check_notifier_(task_runner_,
                               base::Bind(&TileManager::CheckAndIssueSignals,
                                          base::Unretained(this))),
       has_scheduled_tile_tasks_(false),
       prepare_tiles_count_(0u),
       next_tile_id_(0u),
+      check_tile_priority_inversion_(check_tile_priority_inversion),
       task_set_finished_weak_ptr_factory_(this) {}
 
 TileManager::~TileManager() {
   FinishTasksAndCleanUp();
 }
 
 void TileManager::FinishTasksAndCleanUp() {
   if (!tile_task_manager_)
     return;
 
@@ skipping 367 matching lines @@
     work_to_schedule.tiles_to_raster.push_back(prioritized_tile);
 
     // Since we scheduled the tile, set whether it was a prepaint or not
     // assuming that the tile will successfully finish running. We don't have
     // priority information at the time the tile completes, so it should be done
     // here.
     if (!tile_is_needed_now)
       tile->draw_info().set_was_a_prepaint_tile();
   }
 
+  // Debugging to check that remaining tiles in the priority queue are not in
+  // the NOW bin and are required for neither activation nor draw.
+  // This runs if the following conditions hold:
+  //  - check_tile_priority_inversion has been enabled.
+  //  - the loop above has processed all tiles that would be needed for any
+  //    signals to fire (that is,
+  //    all_tiles_that_need_to_be_rasterized_are_scheduled_ is true)
+  //  - Memory limit policy allows for any tiles to be scheduled at all (ie it's
+  //    not ALLOW_NOTHING).
+  if (check_tile_priority_inversion_ &&
+      all_tiles_that_need_to_be_rasterized_are_scheduled_ &&
+      global_state_.memory_limit_policy != ALLOW_NOTHING) {
+    TilePriority::PriorityBin highest_bin_found = TilePriority::NOW;
+    for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
+      const PrioritizedTile& prioritized_tile = raster_priority_queue->Top();
+      Tile* tile = prioritized_tile.tile();
+      TilePriority priority = prioritized_tile.priority();
+
+      if (priority.priority_bin > highest_bin_found)
+        highest_bin_found = priority.priority_bin;
+
+      CHECK_NE(TilePriority::NOW, priority.priority_bin)
+          << "mode: " << global_state_.tree_priority
+          << " highest bin: " << highest_bin_found;
+      CHECK(!tile->required_for_activation())
+          << "mode: " << global_state_.tree_priority
+          << " bin: " << priority.priority_bin
+          << " highest bin: " << highest_bin_found;
+      CHECK(!tile->required_for_draw())
+          << "mode: " << global_state_.tree_priority
+          << " bin: " << priority.priority_bin
+          << " highest bin: " << highest_bin_found;
+    }
+  }
+
   // Note that we should try and further reduce memory in case the above loop
   // didn't reduce memory. This ensures that we always release as many resources
   // as possible to stay within the memory limit.
   eviction_priority_queue = FreeTileResourcesUntilUsageIsWithinLimit(
       std::move(eviction_priority_queue), hard_memory_limit, &memory_usage);
 
   UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget",
                         !had_enough_memory_to_schedule_tiles_needed_now);
   did_oom_on_last_assign_ = !had_enough_memory_to_schedule_tiles_needed_now;
 
@@ skipping 579 matching lines @@
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default;
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule(
     PrioritizedWorkToSchedule&& other) = default;
 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default;
 
 }  // namespace cc