cc: Split tiling set raster queues into all and required.

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 405 matching lines @@
   // 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-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 have to rebuilt the
   // queue in case the last AssignGpuMemoryToTiles evicted some tiles that would
   // otherwise not be picked up by the old raster queue.
+  // TODO(hendrikw): This doesn't seem to do anything, remove?

[vmpstr, 2015/01/08 21:06:08]

hendrikw, FYI.

   client_->BuildRasterQueue(&raster_priority_queue_,
-                            global_state_.tree_priority);
+                            global_state_.tree_priority,
+                            RasterTilePriorityQueue::Type::ALL);
 
   // Use on-demand raster for any tiles that have not been been assigned
   // memory. This ensures that we draw even when OOM.
   while (!raster_priority_queue_.IsEmpty()) {
     Tile* tile = raster_priority_queue_.Top();
     TileDrawInfo& draw_info = tile->draw_info();
 
     if (tile->required_for_draw() && !draw_info.IsReadyToDraw()) {
       draw_info.set_rasterize_on_demand();
       client_->NotifyTileStateChanged(tile);
@@ skipping 135 matching lines @@
   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;
+  // TODO(vmpstr): Take this as a parameter and have SynchronousRaster build a
+  // REQUIRED_FOR_DRAW queue.
   client_->BuildRasterQueue(&raster_priority_queue_,
-                            global_state_.tree_priority);
+                            global_state_.tree_priority,
+                            RasterTilePriorityQueue::Type::ALL);
 
   while (!raster_priority_queue_.IsEmpty()) {
     Tile* tile = raster_priority_queue_.Top();
 
     // TODO(vmpstr): Remove this when the iterator returns the correct tiles
     // to draw for GPU rasterization.
     if (required_for_draw_only) {
       if (!tile->required_for_draw()) {
         raster_priority_queue_.Pop();
         continue;
@@ skipping 278 matching lines @@
 void TileManager::SetTileTaskRunnerForTesting(
     TileTaskRunner* tile_task_runner) {
   tile_task_runner_ = tile_task_runner;
   tile_task_runner_->SetClient(this);
 }
 
 bool TileManager::IsReadyToActivate() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToActivate");
   const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
 
+  // TODO(vmpstr): Replace this with building a REQUIRED_TO_ACTIVATE raster
+  // queue and checking if it's empty.
   for (const auto& layer : layers) {
     if (!layer->AllTilesRequiredForActivationAreReadyToDraw())
       return false;
   }
 
   return true;
 }
 
 bool TileManager::IsReadyToDraw() const {
   const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
 
+  // TODO(vmpstr): Replace this with building a REQUIRED_TO_DRAW raster queue
+  // and checking if it's empty.
   for (const auto& layer : layers) {
     if (!layer->AllTilesRequiredForDrawAreReadyToDraw())
       return false;
   }
 
   return true;
 }
 
 void TileManager::NotifyReadyToActivate() {
   TRACE_EVENT0("cc", "TileManager::NotifyReadyToActivate");
@@ skipping 68 matching lines @@
   // 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 have to rebuilt the
   // queue in case the last AssignGpuMemoryToTiles evicted some tiles that
   // would otherwise not be picked up by the old raster queue.
+  // TODO(vmpstr): Make this use REQUIRED_FOR_ACTIVAITON queue.

[vmpstr, 2015/01/08 21:06:08]

I could just make the change now, but I'd prefer to land the bulk of the work
first, then "enable" it. Let me know if that's fine

[danakj, 2015/01/08 23:24:40]

Yes sounds good. Then you can add a test to show the change doing something
along with it, if possible maybe :)

[vmpstr, 2015/01/09 20:21:40]

The change would just simply this code, but end up with no change in behavior.
But yes, I would verify that if this code isn't there something breaks :P

   client_->BuildRasterQueue(&raster_priority_queue_,
-                            global_state_.tree_priority);
+                            global_state_.tree_priority,
+                            RasterTilePriorityQueue::Type::ALL);
   bool ready_to_activate = true;
   while (!raster_priority_queue_.IsEmpty()) {
     Tile* tile = raster_priority_queue_.Top();
     TileDrawInfo& draw_info = tile->draw_info();
 
     if (tile->required_for_activation() && !draw_info.IsReadyToDraw()) {
       // If we can't raster on demand, give up early (and don't activate).
       if (!allow_rasterize_on_demand) {
         ready_to_activate = false;
         break;
@@ skipping 56 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