cc: Refactor how picture layers are exposed to the tile manager.

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 402 matching lines @@
   rasterizer_->ScheduleTasks(&empty);
   orphan_raster_tasks_.clear();
 
   // This should finish all pending tasks and release any uninitialized
   // resources.
   rasterizer_->Shutdown();
   rasterizer_->CheckForCompletedTasks();
 
   DCHECK_EQ(0u, bytes_releasable_);
   DCHECK_EQ(0u, resources_releasable_);
-
-  for (std::vector<PictureLayerImpl*>::iterator it = layers_.begin();
-       it != layers_.end();
-       ++it) {
-    (*it)->DidUnregisterLayer();
-  }
-  layers_.clear();
 }
 
 void TileManager::Release(Tile* tile) {
   prioritized_tiles_dirty_ = true;
   released_tiles_.push_back(tile);
 }
 
 void TileManager::DidChangeTilePriority(Tile* tile) {
   prioritized_tiles_dirty_ = true;
 }
@@ skipping 229 matching lines @@
         !mts.tile_versions[mts.raster_mode].raster_task_) {
       FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
       continue;
     }
 
     // Insert the tile into a priority set.
     tiles->InsertTile(tile, mts.bin);
   }
 }
 
-void TileManager::CleanUpLayers() {
-  for (size_t i = 0; i < layers_.size(); ++i) {
-    if (layers_[i]->IsDrawnRenderSurfaceLayerListMember())
-      continue;
-
-    layers_[i]->DidUnregisterLayer();
-    std::swap(layers_[i], layers_.back());
-    layers_.pop_back();
-    --i;
-    prioritized_tiles_dirty_ = true;
-  }
-}
-
 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
 
   // Update internal state.
   if (state != global_state_) {
     global_state_ = state;
     prioritized_tiles_dirty_ = true;
   }
 
-  CleanUpLayers();
-
   // We need to call CheckForCompletedTasks() once in-between each call
   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
   if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
     rasterizer_->CheckForCompletedTasks();
     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
   }
 
   UpdatePrioritizedTileSetIfNeeded();
 
   TileVector tiles_that_need_to_be_rasterized;
@@ skipping 499 matching lines @@
                                                          source_frame_number,
                                                          flags));
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile;
   used_layer_counts_[tile->layer_id()]++;
   prioritized_tiles_dirty_ = true;
   return tile;
 }
 
-void TileManager::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
-  DCHECK(std::find(layers_.begin(), layers_.end(), layer) == layers_.end());
-  layers_.push_back(layer);
-}
-
-void TileManager::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
-  std::vector<PictureLayerImpl*>::iterator it =
-      std::find(layers_.begin(), layers_.end(), layer);
-  DCHECK(it != layers_.end());
-  layers_.erase(it);
-}
-
 void TileManager::GetPairedPictureLayers(
     std::vector<PairedPictureLayer>* paired_layers) const {
+  const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
+
   paired_layers->clear();
   // Reserve a maximum possible paired layers.
-  paired_layers->reserve(layers_.size());
+  paired_layers->reserve(layers.size());
 
-  for (std::vector<PictureLayerImpl*>::const_iterator it = layers_.begin();
-       it != layers_.end();
+  for (std::vector<PictureLayerImpl*>::const_iterator it = layers.begin();
+       it != layers.end();
        ++it) {
     PictureLayerImpl* layer = *it;
 
-    // This is a recycle tree layer, we can safely skip since the tiles on this
-    // layer have to be accessible via the active tree.
-    if (!layer->IsOnActiveOrPendingTree())
+    // TODO(vmpstr): Iterators and should handle this instead. crbug.com/381704
+    if (!layer->HasValidTilePriorities())
       continue;
 
     PictureLayerImpl* twin_layer = layer->GetTwinLayer();
 
-    // If the twin layer is recycled, it is not a valid twin.
-    if (twin_layer && !twin_layer->IsOnActiveOrPendingTree())
+    // Ignore the twin layer when tile priorities are invalid.
+    // TODO(vmpstr): Iterators should handle this instead. crbug.com/381704
+    if (twin_layer && !twin_layer->HasValidTilePriorities())
       twin_layer = NULL;
 
     PairedPictureLayer paired_layer;
     WhichTree tree = layer->GetTree();
 
     // If the current tree is ACTIVE_TREE, then always generate a paired_layer.
     // If current tree is PENDING_TREE, then only generate a paired_layer if
     // there is no twin layer.
     if (tree == ACTIVE_TREE) {
       DCHECK(!twin_layer || twin_layer->GetTree() == PENDING_TREE);
@@ skipping 179 matching lines @@
   const TilePriority& a_priority =
       a_tile->priority_for_tree_priority(tree_priority_);
   const TilePriority& b_priority =
       b_tile->priority_for_tree_priority(tree_priority_);
   bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY;
 
   // Now we have to return true iff b is higher priority than a.
 
   // If the bin is the same but the resolution is not, then the order will be
   // determined by whether we prioritize low res or not.
+  // TODO(vmpstr): Remove this when TilePriority is no longer a member of Tile
+  // class but instead produced by the iterators.
   if (b_priority.priority_bin == a_priority.priority_bin &&
       b_priority.resolution != a_priority.resolution) {
     // Non ideal resolution should be sorted lower than other resolutions.
     if (a_priority.resolution == NON_IDEAL_RESOLUTION)
       return true;
 
     if (b_priority.resolution == NON_IDEAL_RESOLUTION)
       return false;
 
     if (prioritize_low_res)
@@ skipping 169 matching lines @@
   }
   return a_priority.IsHigherPriorityThan(b_priority);
 }
 
 void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) {
   rasterizer_ = rasterizer;
   rasterizer_->SetClient(this);
 }
 
 bool TileManager::IsReadyToActivate() const {
-  for (std::vector<PictureLayerImpl*>::const_iterator it = layers_.begin();
-       it != layers_.end();
+  const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
+
+  for (std::vector<PictureLayerImpl*>::const_iterator it = layers.begin();
+       it != layers.end();
        ++it) {
     if (!(*it)->AllTilesRequiredForActivationAreReadyToDraw())
       return false;
   }
 
   return true;
 }
 
 void TileManager::CheckIfReadyToActivate() {
   TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
 
   rasterizer_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   if (IsReadyToActivate())
     client_->NotifyReadyToActivate();
 }
 
 }  // namespace cc