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

cc/resources/tile_manager.cc

Index: cc/resources/tile_manager.cc
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 2b247aa20856e22a2ba12b321ce0d3dd6f2e9d7c..1de7b504bb70b68264a328d9aca81c8366bff62c 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -263,6 +263,38 @@ TileManager::~TileManager() {
   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);
 }
@@ -360,8 +392,7 @@ void TileManager::PrepareTiles(
 
     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(
@@ -413,9 +444,7 @@ void TileManager::SynchronouslyRasterizeTiles(
   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(),
@@ -435,9 +464,8 @@ void TileManager::SynchronouslyRasterizeTiles(
   // 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.
@@ -499,10 +527,8 @@ TileManager::FreeTileResourcesUntilUsageIsWithinLimit(
     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;
 
@@ -521,10 +547,8 @@ TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
     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;
 
@@ -873,7 +897,7 @@ void TileManager::SetTileTaskRunnerForTesting(
 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
@@ -897,6 +921,21 @@ bool TileManager::IsReadyToDraw() const {
       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_)
@@ -949,8 +988,7 @@ void TileManager::CheckIfMoreTilesNeedToBePrepared() {
   // 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);
@@ -983,9 +1021,7 @@ void TileManager::CheckIfMoreTilesNeedToBePrepared() {
   // 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.