cc: Do not ignore layers without valid priorities during eviction.

cc/resources/picture_layer_tiling.cc

Index: cc/resources/picture_layer_tiling.cc
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 61b0362ee44c2b9cd073fe86db6e7c238378c69f..c42ec7a1e7f9ed3b810fc17bb4a83e22a4965449 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -742,22 +742,32 @@ bool PictureLayerTiling::IsTileRequiredForActivation(const Tile* tile) const {
   return true;
 }
 
-void PictureLayerTiling::UpdateTileAndTwinPriority(Tile* tile) const {
-  UpdateTilePriority(tile);
+void PictureLayerTiling::UpdateTileAndTwinPriority(
+    Tile* tile,
+    bool use_tile_priority_rects,
+    bool use_twin_tile_priority_rects) const {
+  if (use_tile_priority_rects) {

[vmpstr, 2014/10/31 15:35:49]

How about we add a client_->GetMaxBinForTilePriority() (or GetMaxTilePriority())
or something along those lines, which would return TilePriority::EVENTUALLY for
layers without valid tile priorities, and use that when calculating tile
priorities. I think that's a bit more explicit.

[USE eero AT chromium.org, 2014/11/04 17:47:57]

Done.

+    UpdateTilePriority(tile);
+  } else {
+    WhichTree tree = client_->GetTree();
+    tile->SetPriority(tree, TilePriority());
+    tile->set_is_occluded(tree, false);
+    if (tree == PENDING_TREE)
+      tile->set_required_for_activation(false);
+  }
 
   const PictureLayerTiling* twin_tiling =
       client_->GetPendingOrActiveTwinTiling(this);
-  if (!tile->is_shared() || !twin_tiling) {
+  if (use_twin_tile_priority_rects && tile->is_shared() && twin_tiling) {
+    twin_tiling->UpdateTilePriority(tile);
+  } else {
     WhichTree tree = client_->GetTree();
     WhichTree twin_tree = tree == ACTIVE_TREE ? PENDING_TREE : ACTIVE_TREE;
     tile->SetPriority(twin_tree, TilePriority());
     tile->set_is_occluded(twin_tree, false);
     if (twin_tree == PENDING_TREE)
       tile->set_required_for_activation(false);
-    return;
   }
-
-  twin_tiling->UpdateTilePriority(tile);
 }
 
 void PictureLayerTiling::UpdateTilePriority(Tile* tile) const {
@@ -975,7 +985,9 @@ gfx::Rect PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
 }
 
 void PictureLayerTiling::UpdateEvictionCacheIfNeeded(
-    TreePriority tree_priority) {
+    TreePriority tree_priority,
+    bool use_tile_priority_rects,
+    bool use_twin_tile_priority_rects) {
   if (eviction_tiles_cache_valid_ &&
       eviction_cache_tree_priority_ == tree_priority)
     return;
@@ -989,7 +1001,8 @@ void PictureLayerTiling::UpdateEvictionCacheIfNeeded(
 
   for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = it->second.get();
-    UpdateTileAndTwinPriority(tile);
+    UpdateTileAndTwinPriority(
+        tile, use_tile_priority_rects, use_twin_tile_priority_rects);
     const TilePriority& priority =
         tile->priority_for_tree_priority(tree_priority);
     switch (priority.priority_bin) {
@@ -1040,8 +1053,11 @@ void PictureLayerTiling::UpdateEvictionCacheIfNeeded(
 
 const std::vector<Tile*>* PictureLayerTiling::GetEvictionTiles(
     TreePriority tree_priority,
-    EvictionCategory category) {
-  UpdateEvictionCacheIfNeeded(tree_priority);
+    EvictionCategory category,
+    bool use_tile_priority_rects,
+    bool use_twin_tile_priority_rects) {
+  UpdateEvictionCacheIfNeeded(
+      tree_priority, use_tile_priority_rects, use_twin_tile_priority_rects);
   switch (category) {
     case EVENTUALLY:
       return &eviction_tiles_eventually_;
@@ -1085,7 +1101,7 @@ PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator(
     ++(*this);
     return;
   }
-  tiling_->UpdateTileAndTwinPriority(current_tile_);
+  tiling_->UpdateTileAndTwinPriority(current_tile_, true, true);
 }
 
 PictureLayerTiling::TilingRasterTileIterator::~TilingRasterTileIterator() {}
@@ -1148,7 +1164,7 @@ void PictureLayerTiling::TilingRasterTileIterator::AdvancePhase() {
   } while (!spiral_iterator_);
 
   if (current_tile_)
-    tiling_->UpdateTileAndTwinPriority(current_tile_);
+    tiling_->UpdateTileAndTwinPriority(current_tile_, true, true);
 }
 
 PictureLayerTiling::TilingRasterTileIterator&
@@ -1188,7 +1204,7 @@ operator++() {
   }
 
   if (current_tile_)
-    tiling_->UpdateTileAndTwinPriority(current_tile_);
+    tiling_->UpdateTileAndTwinPriority(current_tile_, true, true);
   return *this;
 }
 
@@ -1199,8 +1215,13 @@ PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator()
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
     PictureLayerTiling* tiling,
     TreePriority tree_priority,
-    EvictionCategory category)
-    : eviction_tiles_(tiling->GetEvictionTiles(tree_priority, category)),
+    EvictionCategory category,
+    bool use_tile_priority_rects,
+    bool use_twin_tile_priority_rects)
+    : eviction_tiles_(tiling->GetEvictionTiles(tree_priority,
+                                               category,
+                                               use_tile_priority_rects,
+                                               use_twin_tile_priority_rects)),
       // Note: initializing to "0 - 1" works as overflow is well defined for
       // unsigned integers.
       current_eviction_tiles_index_(static_cast<size_t>(0) - 1) {