cc: Rework how picture layer tiling set gets into raster queues.

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 245 matching lines @@
 
   // This should finish all pending tasks and release any uninitialized
   // resources.
   tile_task_runner_->Shutdown();
   tile_task_runner_->CheckForCompletedTasks();
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 }
 
+void TileManager::RegisterPictureLayerTilingSet(

[enne (OOO), 2015/02/10 21:28:31]

This is way better than building pairs every time.  Is there any perf
improvement, or is this just a cleanup?

[vmpstr, 2015/02/11 21:37:16]

This is meant to be a cleanup, but I'll get some perf numbers tomorrow.

+    int layer_id,
+    WhichTree tree,
+    PictureLayerTilingSet* tiling_set) {
+  auto& paired_tiling_set = paired_picture_layer_tiling_sets_[layer_id];
+  if (tree == ACTIVE_TREE) {
+    DCHECK(!paired_tiling_set.active);
+    paired_tiling_set.active = tiling_set;
+  } else {
+    DCHECK(!paired_tiling_set.pending);
+    paired_tiling_set.pending = tiling_set;
+  }
+}
+
+void TileManager::UnregisterPictureLayerTilingSet(int layer_id,
+                                                  WhichTree tree) {
+  auto paired_tiling_set_it = paired_picture_layer_tiling_sets_.find(layer_id);
+  DCHECK(paired_tiling_set_it != paired_picture_layer_tiling_sets_.end());
+
+  auto& paired_tiling_set = paired_tiling_set_it->second;
+  if (tree == ACTIVE_TREE) {
+    DCHECK(paired_tiling_set.active);
+    paired_tiling_set.active = nullptr;
+  } else {
+    DCHECK(paired_tiling_set.pending);
+    paired_tiling_set.pending = nullptr;
+  }
+
+  if (!paired_tiling_set.active && !paired_tiling_set.pending)
+    paired_picture_layer_tiling_sets_.erase(paired_tiling_set_it);
+}
+
 void TileManager::Release(Tile* tile) {
   released_tiles_.push_back(tile);
 }
 
 TaskSetCollection TileManager::TasksThatShouldBeForcedToComplete() const {
   TaskSetCollection tasks_that_should_be_forced_to_complete;
   if (global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY)
     tasks_that_should_be_forced_to_complete[REQUIRED_FOR_ACTIVATION] = true;
   return tasks_that_should_be_forced_to_complete;
 }
@@ skipping 77 matching lines @@
     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;
     scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
-        client_->BuildRasterQueue(global_state_.tree_priority,
-                                  RasterTilePriorityQueue::Type::ALL));
+        BuildRasterQueue(RasterTilePriorityQueue::Type::ALL));
     // Inform the client that will likely require a draw if the top tile is
     // required for draw.
     client_->SetIsLikelyToRequireADraw(
         !raster_priority_queue->IsEmpty() &&
         raster_priority_queue->Top()->required_for_draw());
     AssignGpuMemoryToTiles(raster_priority_queue.get(),
                            scheduled_raster_task_limit_,
                            &tiles_that_need_to_be_rasterized);
 
     // Schedule tile tasks.
@@ skipping 31 matching lines @@
 
   DCHECK(rasterizer_->GetPrepareTilesMode() !=
          PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES);
 
   global_state_ = state;
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 
   scoped_ptr<RasterTilePriorityQueue> required_for_draw_queue(
-      client_->BuildRasterQueue(
-          global_state_.tree_priority,
-          RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
+      BuildRasterQueue(RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
   TileVector tiles_that_need_to_be_rasterized;
   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_,
       tile_task_runner_->GetResourceFormat(),
       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 = client_->BuildRasterQueue(
-      global_state_.tree_priority,
-      RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+  required_for_draw_queue =
+      BuildRasterQueue(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();
     tile->draw_info().set_rasterize_on_demand();
     client_->NotifyTileStateChanged(tile);
   }
 
   TRACE_EVENT_INSTANT1("cc", "DidRasterize", TRACE_EVENT_SCOPE_THREAD, "state",
@@ skipping 41 matching lines @@
   global_state_.AsValueInto(state);
   state->EndDictionary();
 }
 
 scoped_ptr<EvictionTilePriorityQueue>
 TileManager::FreeTileResourcesUntilUsageIsWithinLimit(
     scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
     const MemoryUsage& limit,
     MemoryUsage* usage) {
   while (usage->Exceeds(limit)) {
-    if (!eviction_priority_queue) {
-      eviction_priority_queue =
-          client_->BuildEvictionQueue(global_state_.tree_priority);
-    }
+    if (!eviction_priority_queue)
+      eviction_priority_queue = BuildEvictionQueue();
     if (eviction_priority_queue->IsEmpty())
       break;
 
     Tile* tile = eviction_priority_queue->Top();
     *usage -= MemoryUsage::FromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
     eviction_priority_queue->Pop();
   }
   return eviction_priority_queue;
 }
 
 scoped_ptr<EvictionTilePriorityQueue>
 TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
     scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
     const MemoryUsage& limit,
     const TilePriority& other_priority,
     MemoryUsage* usage) {
   while (usage->Exceeds(limit)) {
-    if (!eviction_priority_queue) {
-      eviction_priority_queue =
-          client_->BuildEvictionQueue(global_state_.tree_priority);
-    }
+    if (!eviction_priority_queue)
+      eviction_priority_queue = BuildEvictionQueue();
     if (eviction_priority_queue->IsEmpty())
       break;
 
     Tile* tile = eviction_priority_queue->Top();
     if (!other_priority.IsHigherPriorityThan(tile->combined_priority()))
       break;
 
     *usage -= MemoryUsage::FromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
     eviction_priority_queue->Pop();
@@ skipping 328 matching lines @@
 
 void TileManager::SetTileTaskRunnerForTesting(
     TileTaskRunner* tile_task_runner) {
   tile_task_runner_ = tile_task_runner;
   tile_task_runner_->SetClient(this);
 }
 
 bool TileManager::AreRequiredTilesReadyToDraw(
     RasterTilePriorityQueue::Type type) const {
   scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
-      client_->BuildRasterQueue(global_state_.tree_priority, type));
+      BuildRasterQueue(type));
   // It is insufficient to check whether the raster queue we constructed is
   // empty. The reason for this is that there are situations (rasterize on
   // demand) when the tile both needs raster and it's ready to draw. Hence, we
   // have to iterate the queue to check whether the required tiles are ready to
   // draw.
   for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
     if (!raster_priority_queue->Top()->IsReadyToDraw())
       return false;
   }
   return true;
 }
 bool TileManager::IsReadyToActivate() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToActivate");
   return AreRequiredTilesReadyToDraw(
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
 }
 
 bool TileManager::IsReadyToDraw() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToDraw");
   return AreRequiredTilesReadyToDraw(
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
 }
 
+scoped_ptr<RasterTilePriorityQueue> TileManager::BuildRasterQueue(
+    RasterTilePriorityQueue::Type type) const {
+  TRACE_EVENT0("cc", "TileManager::BuildRasterQueue");
+  return RasterTilePriorityQueue::Create(paired_picture_layer_tiling_sets_,
+                                         client_->PendingTreeExists(),
+                                         global_state_.tree_priority, type);
+}
+
+scoped_ptr<EvictionTilePriorityQueue> TileManager::BuildEvictionQueue() const {
+  TRACE_EVENT0("cc", "TileManager::BuildEvictionQueue");
+  return EvictionTilePriorityQueue::Create(paired_picture_layer_tiling_sets_,
+                                           client_->PendingTreeExists(),
+                                           global_state_.tree_priority);
+}
+
 void TileManager::NotifyReadyToActivate() {
   TRACE_EVENT0("cc", "TileManager::NotifyReadyToActivate");
   if (did_notify_ready_to_activate_)
     return;
   client_->NotifyReadyToActivate();
   did_notify_ready_to_activate_ = true;
 }
 
 void TileManager::NotifyReadyToDraw() {
   TRACE_EVENT0("cc", "TileManager::NotifyReadyToDraw");
@@ skipping 32 matching lines @@
 }
 
 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;
   scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
-      client_->BuildRasterQueue(global_state_.tree_priority,
-                                RasterTilePriorityQueue::Type::ALL));
+      BuildRasterQueue(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;
   }
@@ skipping 12 matching lines @@
       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.
   scoped_ptr<RasterTilePriorityQueue> required_for_activation_queue(
-      client_->BuildRasterQueue(
-          global_state_.tree_priority,
-          RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
+      BuildRasterQueue(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)
     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();
@@ skipping 49 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