cc: Split RasterTilePriorityQueue into required and all based on type.

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 342 matching lines @@
     // to ScheduleTasks() to prevent canceled tasks from being scheduled.
     if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
       tile_task_runner_->CheckForCompletedTasks();
       did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
     }
 
     FreeResourcesForReleasedTiles();
     CleanUpReleasedTiles();
 
     TileVector tiles_that_need_to_be_rasterized;
-    RasterTilePriorityQueue raster_priority_queue;
-    client_->BuildRasterQueue(&raster_priority_queue,
-                              global_state_.tree_priority,
-                              RasterTilePriorityQueue::Type::ALL);
-    AssignGpuMemoryToTiles(&raster_priority_queue, scheduled_raster_task_limit_,
+    scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
+        client_->BuildRasterQueue(global_state_.tree_priority,
+                                  RasterTilePriorityQueue::Type::ALL));
+    AssignGpuMemoryToTiles(raster_priority_queue.get(),
+                           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
@@ skipping 26 matching lines @@
   TRACE_EVENT0("cc", "TileManager::SynchronouslyRasterizeTiles");
 
   DCHECK(rasterizer_->GetPrepareTilesMode() !=
          PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES);
 
   global_state_ = state;
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 
-  RasterTilePriorityQueue required_for_draw_queue;
-  client_->BuildRasterQueue(&required_for_draw_queue,
-                            global_state_.tree_priority,
-                            RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+  scoped_ptr<RasterTilePriorityQueue> required_for_draw_queue(
+      client_->BuildRasterQueue(
+          global_state_.tree_priority,
+          RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
   TileVector tiles_that_need_to_be_rasterized;
-  AssignGpuMemoryToTiles(&required_for_draw_queue,
+  AssignGpuMemoryToTiles(required_for_draw_queue.get(),
                          std::numeric_limits<size_t>::max(),
                          &tiles_that_need_to_be_rasterized);
 
   // We must reduce the amount of unused resources before calling
   // RunTasks to prevent usage from rising above limits.
   resource_pool_->ReduceResourceUsage();
 
   // Run and complete all raster task synchronously.
   rasterizer_->RasterizeTiles(
       tiles_that_need_to_be_rasterized, resource_pool_,
       base::Bind(&TileManager::UpdateTileDrawInfo, base::Unretained(this)));
 
   // Use on-demand raster for any required-for-draw tiles that have not been
   // assigned memory after reaching a steady memory state.
   // TODO(hendrikw): Figure out why this would improve jank on some tests - See
   // crbug.com/449288
-  required_for_draw_queue.Reset();
-  client_->BuildRasterQueue(&required_for_draw_queue,
-                            global_state_.tree_priority,
-                            RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+  required_for_draw_queue = client_->BuildRasterQueue(
+      global_state_.tree_priority,
+      RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
 
   // Use on-demand raster for any tiles that have not been been assigned
   // memory. This ensures that we draw even when OOM.
-  for (; !required_for_draw_queue.IsEmpty(); required_for_draw_queue.Pop()) {
-    Tile* tile = required_for_draw_queue.Top();
+  for (; !required_for_draw_queue->IsEmpty(); required_for_draw_queue->Pop()) {
+    Tile* tile = required_for_draw_queue->Top();
     tile->draw_info().set_rasterize_on_demand();
     client_->NotifyTileStateChanged(tile);
   }
 
   TRACE_EVENT_INSTANT1("cc", "DidRasterize", TRACE_EVENT_SCOPE_THREAD, "state",
                        BasicStateAsValue());
 
   TRACE_COUNTER_ID1("cc", "unused_memory_bytes", this,
                     resource_pool_->total_memory_usage_bytes() -
                         resource_pool_->acquired_memory_usage_bytes());
@@ skipping 482 matching lines @@
   NotifyReadyToDraw();
 }
 
 void TileManager::CheckIfMoreTilesNeedToBePrepared() {
   tile_task_runner_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.
   TileVector tiles_that_need_to_be_rasterized;
-  RasterTilePriorityQueue raster_priority_queue;
-  client_->BuildRasterQueue(&raster_priority_queue, global_state_.tree_priority,
-                            RasterTilePriorityQueue::Type::ALL);
-  AssignGpuMemoryToTiles(&raster_priority_queue, scheduled_raster_task_limit_,
+  scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
+      client_->BuildRasterQueue(global_state_.tree_priority,
+                                RasterTilePriorityQueue::Type::ALL));
+  AssignGpuMemoryToTiles(raster_priority_queue.get(),
+                         scheduled_raster_task_limit_,
                          &tiles_that_need_to_be_rasterized);
 
   // |tiles_that_need_to_be_rasterized| will be empty when we reach a
   // steady memory state. Keep scheduling tasks until we reach this state.
   if (!tiles_that_need_to_be_rasterized.empty()) {
     ScheduleTasks(tiles_that_need_to_be_rasterized);
     return;
   }
 
   FreeResourcesForReleasedTiles();
 
   resource_pool_->ReduceResourceUsage();
 
   // We don't reserve memory for required-for-activation tiles during
   // accelerated gestures, so we just postpone activation when we don't
   // have these tiles, and activate after the accelerated gesture.
   // Likewise if we don't allow any tiles (as is the case when we're
   // invisible), if we have tiles that aren't ready, then we shouldn't
   // activate as activation can cause checkerboards.
   bool allow_rasterize_on_demand =
       global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY &&
       global_state_.memory_limit_policy != ALLOW_NOTHING;
 
   // Use on-demand raster for any required-for-activation tiles that have
   // not been been assigned memory after reaching a steady memory state. This
   // ensures that we activate even when OOM. Note that we can't reuse the queue
   // we used for AssignGpuMemoryToTiles, since the AssignGpuMemoryToTiles call
   // could have evicted some tiles that would not be picked up by the old raster
   // queue.
-  RasterTilePriorityQueue required_for_activation_queue;
-  client_->BuildRasterQueue(
-      &required_for_activation_queue, global_state_.tree_priority,
-      RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
+  scoped_ptr<RasterTilePriorityQueue> required_for_activation_queue(
+      client_->BuildRasterQueue(
+          global_state_.tree_priority,
+          RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
 
   // If we have tiles to mark as rasterize on demand, but we don't allow
   // rasterize on demand, then skip activation and return early.
-  if (!required_for_activation_queue.IsEmpty() && !allow_rasterize_on_demand)
+  if (!required_for_activation_queue->IsEmpty() && !allow_rasterize_on_demand)
     return;
 
   // Mark required tiles as rasterize on demand.
-  for (; !required_for_activation_queue.IsEmpty();
-       required_for_activation_queue.Pop()) {
-    Tile* tile = required_for_activation_queue.Top();
+  for (; !required_for_activation_queue->IsEmpty();
+       required_for_activation_queue->Pop()) {
+    Tile* tile = required_for_activation_queue->Top();
     tile->draw_info().set_rasterize_on_demand();
     client_->NotifyTileStateChanged(tile);
   }
 
   DCHECK(IsReadyToActivate());
   ready_to_activate_check_notifier_.Schedule();
 }
 
 TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) {
 }
@@ skipping 39 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