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

cc/resources/picture_layer_tiling.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/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 724 matching lines @@
   Tile* twin_tile =
       twin_tiling->TileAt(tile->tiling_i_index(), tile->tiling_j_index());
   // If twin tile is missing, it might not have a recording, so we don't need
   // this tile to be required for activation.
   if (!twin_tile)
     return false;
 
   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 {
   // TODO(vmpstr): This code should return the priority instead of setting it on
   // the tile. This should be a part of the change to move tile priority from
   // tiles into iterators.
   WhichTree tree = client_->GetTree();
 
   DCHECK_EQ(TileAt(tile->tiling_i_index(), tile->tiling_j_index()), tile);
   gfx::Rect tile_bounds =
@@ skipping 197 matching lines @@
       break;
   }
 
   gfx::Rect result(origin_x, origin_y, width, height);
   if (cache)
     cache->previous_result = result;
   return result;
 }
 
 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;
 
   eviction_tiles_now_.clear();
   eviction_tiles_now_and_required_for_activation_.clear();
   eviction_tiles_soon_.clear();
   eviction_tiles_soon_and_required_for_activation_.clear();
   eviction_tiles_eventually_.clear();
   eviction_tiles_eventually_and_required_for_activation_.clear();
 
   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) {
       case TilePriority::EVENTUALLY:
         if (tile->required_for_activation())
           eviction_tiles_eventually_and_required_for_activation_.push_back(
               tile);
         else
           eviction_tiles_eventually_.push_back(tile);
         break;
@@ skipping 30 matching lines @@
   std::sort(eviction_tiles_eventually_and_required_for_activation_.begin(),
             eviction_tiles_eventually_and_required_for_activation_.end(),
             sort_order);
 
   eviction_tiles_cache_valid_ = true;
   eviction_cache_tree_priority_ = tree_priority;
 }
 
 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_;
     case EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION:
       return &eviction_tiles_eventually_and_required_for_activation_;
     case SOON:
       return &eviction_tiles_soon_;
     case SOON_AND_REQUIRED_FOR_ACTIVATION:
       return &eviction_tiles_soon_and_required_for_activation_;
     case NOW:
@@ skipping 23 matching lines @@
     AdvancePhase();
     return;
   }
 
   current_tile_ =
       tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y());
   if (!current_tile_ || !TileNeedsRaster(current_tile_)) {
     ++(*this);
     return;
   }
-  tiling_->UpdateTileAndTwinPriority(current_tile_);
+  tiling_->UpdateTileAndTwinPriority(current_tile_, true, true);
 }
 
 PictureLayerTiling::TilingRasterTileIterator::~TilingRasterTileIterator() {}
 
 void PictureLayerTiling::TilingRasterTileIterator::AdvancePhase() {
   DCHECK_LT(phase_, EVENTUALLY_RECT);
 
   do {
     phase_ = static_cast<Phase>(phase_ + 1);
     switch (phase_) {
@@ skipping 42 matching lines @@
       ++spiral_iterator_;
     }
 
     if (!spiral_iterator_ && phase_ == EVENTUALLY_RECT) {
       current_tile_ = NULL;
       break;
     }
   } while (!spiral_iterator_);
 
   if (current_tile_)
-    tiling_->UpdateTileAndTwinPriority(current_tile_);
+    tiling_->UpdateTileAndTwinPriority(current_tile_, true, true);
 }
 
 PictureLayerTiling::TilingRasterTileIterator&
 PictureLayerTiling::TilingRasterTileIterator::
 operator++() {
   current_tile_ = NULL;
   while (!current_tile_ || !TileNeedsRaster(current_tile_)) {
     std::pair<int, int> next_index;
     switch (phase_) {
       case VISIBLE_RECT:
@@ skipping 19 matching lines @@
           current_tile_ = NULL;
           return *this;
         }
         next_index = spiral_iterator_.index();
         break;
     }
     current_tile_ = tiling_->TileAt(next_index.first, next_index.second);
   }
 
   if (current_tile_)
-    tiling_->UpdateTileAndTwinPriority(current_tile_);
+    tiling_->UpdateTileAndTwinPriority(current_tile_, true, true);
   return *this;
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator()
     : eviction_tiles_(NULL), current_eviction_tiles_index_(0u) {
 }
 
 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) {
   DCHECK(eviction_tiles_);
   ++(*this);
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::~TilingEvictionTileIterator() {
 }
 
@@ skipping 18 matching lines @@
   DCHECK(*this);
   do {
     ++current_eviction_tiles_index_;
   } while (current_eviction_tiles_index_ != eviction_tiles_->size() &&
            !(*eviction_tiles_)[current_eviction_tiles_index_]->HasResources());
 
   return *this;
 }
 
 }  // namespace cc