cc: Make eviction queue building consistent with raster.

cc/resources/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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 222 matching lines @@
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToActivate,
                      base::Unretained(this))),
       ready_to_draw_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))),
       more_tiles_need_prepare_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
                      base::Unretained(this))),
-      eviction_priority_queue_is_up_to_date_(false),
       did_notify_ready_to_activate_(false),
       did_notify_ready_to_draw_(false) {
   tile_task_runner_->SetClient(this);
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
 
@@ skipping 113 matching lines @@
                            scheduled_raster_task_limit_,
                            &tiles_that_need_to_be_rasterized);
 
     // Schedule tile tasks.
     ScheduleTasks(tiles_that_need_to_be_rasterized);
 
     did_notify_ready_to_activate_ = false;
     did_notify_ready_to_draw_ = false;
   } else {
     if (global_state_.hard_memory_limit_in_bytes == 0) {
-      // TODO(vmpstr): Add a function to unconditionally create an eviction
-      // queue and guard the rest of the calls sites with this flag, instead of
-      // clearing here and building, which is a bit awkward.
-      eviction_priority_queue_is_up_to_date_ = false;
       resource_pool_->CheckBusyResources(false);
       MemoryUsage memory_limit(0, 0);
       MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
                                resource_pool_->acquired_resource_count());
-      FreeTileResourcesUntilUsageIsWithinLimit(memory_limit, &memory_usage);
+      FreeTileResourcesUntilUsageIsWithinLimit(nullptr, memory_limit,
+                                               &memory_usage);
     }
 
     did_notify_ready_to_activate_ = false;
     did_notify_ready_to_draw_ = false;
     ready_to_activate_notifier_.Schedule();
     ready_to_draw_notifier_.Schedule();
   }
 
   TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD,
                        "state", BasicStateAsValue());
@@ skipping 88 matching lines @@
 }
 
 void TileManager::BasicStateAsValueInto(base::debug::TracedValue* state) const {
   state->SetInteger("tile_count", tiles_.size());
   state->SetBoolean("did_oom_on_last_assign", did_oom_on_last_assign_);
   state->BeginDictionary("global_state");
   global_state_.AsValueInto(state);
   state->EndDictionary();
 }
 
-void TileManager::RebuildEvictionQueueIfNeeded() {
-  TRACE_EVENT1("cc",
-               "TileManager::RebuildEvictionQueueIfNeeded",
-               "eviction_priority_queue_is_up_to_date",
-               eviction_priority_queue_is_up_to_date_);
-  if (eviction_priority_queue_is_up_to_date_)
-    return;
-
-  eviction_priority_queue_.Reset();
-  client_->BuildEvictionQueue(&eviction_priority_queue_,
-                              global_state_.tree_priority);
-  eviction_priority_queue_is_up_to_date_ = true;
-}
-
-bool TileManager::FreeTileResourcesUntilUsageIsWithinLimit(
+scoped_ptr<EvictionTilePriorityQueue>
+TileManager::FreeTileResourcesUntilUsageIsWithinLimit(
+    scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
     const MemoryUsage& limit,
     MemoryUsage* usage) {
   while (usage->Exceeds(limit)) {
-    RebuildEvictionQueueIfNeeded();
-    if (eviction_priority_queue_.IsEmpty())
-      return false;
+    if (!eviction_priority_queue) {
+      eviction_priority_queue =
+          client_->BuildEvictionQueue(global_state_.tree_priority);
+    }
+    if (eviction_priority_queue->IsEmpty())
+      break;
 
-    Tile* tile = eviction_priority_queue_.Top();
+    Tile* tile = eviction_priority_queue->Top();
     *usage -= MemoryUsage::FromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
-    eviction_priority_queue_.Pop();
+    eviction_priority_queue->Pop();
   }
-  return true;
+  return eviction_priority_queue;
 }
 
-bool TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+scoped_ptr<EvictionTilePriorityQueue>
+TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+    scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
     const MemoryUsage& limit,
     const TilePriority& other_priority,
     MemoryUsage* usage) {
   while (usage->Exceeds(limit)) {
-    RebuildEvictionQueueIfNeeded();
-    if (eviction_priority_queue_.IsEmpty())
-      return false;
+    if (!eviction_priority_queue) {
+      eviction_priority_queue =
+          client_->BuildEvictionQueue(global_state_.tree_priority);
+    }
+    if (eviction_priority_queue->IsEmpty())
+      break;
 
-    Tile* tile = eviction_priority_queue_.Top();
+    Tile* tile = eviction_priority_queue->Top();
     if (!other_priority.IsHigherPriorityThan(tile->combined_priority()))
-      return false;
+      break;
 
     *usage -= MemoryUsage::FromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
-    eviction_priority_queue_.Pop();
+    eviction_priority_queue->Pop();
   }
-  return true;
+  return eviction_priority_queue;
 }
 
 bool TileManager::TilePriorityViolatesMemoryPolicy(
     const TilePriority& priority) {
   switch (global_state_.memory_limit_policy) {
     case ALLOW_NOTHING:
       return true;
     case ALLOW_ABSOLUTE_MINIMUM:
       return priority.priority_bin > TilePriority::NOW;
     case ALLOW_PREPAINT_ONLY:
@@ skipping 24 matching lines @@
   all_tiles_that_need_to_be_rasterized_are_scheduled_ = true;
   bool had_enough_memory_to_schedule_tiles_needed_now = true;
 
   MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes,
                                 global_state_.num_resources_limit);
   MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes,
                                 global_state_.num_resources_limit);
   MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
                            resource_pool_->acquired_resource_count());
 
-  eviction_priority_queue_is_up_to_date_ = false;
+  scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue;
   for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
     Tile* tile = raster_priority_queue->Top();
     TilePriority priority = tile->combined_priority();
 
     if (TilePriorityViolatesMemoryPolicy(priority)) {
       TRACE_EVENT_INSTANT0(
           "cc", "TileManager::AssignGpuMemory tile violates memory policy",
           TRACE_EVENT_SCOPE_THREAD);
       break;
     }
@@ skipping 21 matching lines @@
     }
 
     bool tile_is_needed_now = priority.priority_bin == TilePriority::NOW;
 
     // This is the memory limit that will be used by this tile. Depending on
     // the tile priority, it will be one of hard_memory_limit or
     // soft_memory_limit.
     MemoryUsage& tile_memory_limit =
         tile_is_needed_now ? hard_memory_limit : soft_memory_limit;
 
+    const MemoryUsage& scheduled_tile_memory_limit =
+        tile_memory_limit - memory_required_by_tile_to_be_scheduled;
+    eviction_priority_queue =
+        FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+            eviction_priority_queue.Pass(), scheduled_tile_memory_limit,
+            priority, &memory_usage);
     bool memory_usage_is_within_limit =
-        FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
-            tile_memory_limit - memory_required_by_tile_to_be_scheduled,
-            priority, &memory_usage);
+        !memory_usage.Exceeds(scheduled_tile_memory_limit);
 
     // If we couldn't fit the tile into our current memory limit, then we're
     // done.
     if (!memory_usage_is_within_limit) {
       if (tile_is_needed_now)
         had_enough_memory_to_schedule_tiles_needed_now = false;
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
     memory_usage += memory_required_by_tile_to_be_scheduled;
     tiles_that_need_to_be_rasterized->push_back(tile);
   }
 
   // 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.
-  FreeTileResourcesUntilUsageIsWithinLimit(hard_memory_limit, &memory_usage);
+  eviction_priority_queue = FreeTileResourcesUntilUsageIsWithinLimit(
+      eviction_priority_queue.Pass(), 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;
 
   memory_stats_from_last_assign_.total_budget_in_bytes =
       global_state_.hard_memory_limit_in_bytes;
   memory_stats_from_last_assign_.total_bytes_used = memory_usage.memory_bytes();
   memory_stats_from_last_assign_.had_enough_memory =
       had_enough_memory_to_schedule_tiles_needed_now;
@@ skipping 383 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc