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 94b6332a9aa4229bcfaa1b90831beba679a39416..e56af15b1d5a55668e1b2c7da3031b64ee17736f 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -263,6 +263,38 @@ TileManager::~TileManager() {
   CleanUpReleasedTiles();
 }
 
+void TileManager::RegisterPictureLayerTilingSet(
+    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.
@@ -500,10 +528,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;
 
@@ -522,10 +548,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;
 
@@ -874,7 +898,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
@@ -898,6 +922,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_)
@@ -950,8 +989,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);
@@ -984,9 +1022,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.