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;

[sunnyps, 2017/01/04 22:15:22]

Shouldn't this be lowest bin (NOW < SOON < EVENTUALLY)? And shouldn't we process
this in another loop so that we log the correct value in the CHECKs below?

[vmpstr, 2017/01/04 22:49:39]

It's expected that tiles here would be in a higher priority, I just want to log
what the highest one was... for example, was it a SOON bin that appeared before
the NOW or rfa tile, or was it an EVENTUALLY bin? If this value is "NOW" then
the very next tile was rfa/rfd. 

That is, this is just some information about which tiles we looped over before
reaching the problematic one. Once we reach the first problematic one we should
have enough information regardless of the tiles that follow.

I'm not sure this should be a different loop, this is specifically to just the
remainder of the queue.

+
+      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