cc: Remove vectors from tiling eviction tile iterator.

This patch removes vectors from the eviction tile
iterator at the layer level. It reworks the code
a bit to use the underlying layer's tilings
directly using indecies and ranges, instead of
constructing a separate vector to hold the
values.

As well, this ensures that the iterators
are only created when they are visited.


R=reveman

Review URL: https://codereview.chromium.org/428533008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@287688 0039d316-1c4b-4281-b951-d872f2087c98

cc/layers/picture_layer_impl.cc

@@ -1550,135 +1550,200 @@ const Tile* PictureLayerImpl::LayerRasterTileIterator::operator*() const {
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator()
-    : iterator_index_(0),
-      iteration_stage_(TilePriority::EVENTUALLY),
-      required_for_activation_(false),
-      layer_(NULL) {}
+    : current_range_offset_(0),
+      current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
+      current_stage_(EVENTUALLY),
+      tree_priority_(SAME_PRIORITY_FOR_BOTH_TREES),
+      layer_(NULL) {
+}
 
 PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator(
     PictureLayerImpl* layer,
     TreePriority tree_priority)
-    : iterator_index_(0),
-      iteration_stage_(TilePriority::EVENTUALLY),
-      required_for_activation_(false),
+    : current_range_offset_(0),
+      current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
+      current_stage_(EVENTUALLY),
+      tree_priority_(tree_priority),
       layer_(layer) {
-  // Early out if the layer has no tilings.
+  // Early out if the tilings_ object doesn't exist.
   // TODO(vmpstr): Once tile priorities are determined by the iterators, ensure
   // that layers that don't have valid tile priorities have lowest priorities so
   // they evict their tiles first (crbug.com/381704)
-  if (!layer_->tilings_ || !layer_->tilings_->num_tilings())
+  if (!layer_->tilings_)
     return;
 
-  size_t high_res_tiling_index = layer_->tilings_->num_tilings();
-  size_t low_res_tiling_index = layer_->tilings_->num_tilings();
-  for (size_t i = 0; i < layer_->tilings_->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = layer_->tilings_->tiling_at(i);
-    if (tiling->resolution() == HIGH_RESOLUTION)
-      high_res_tiling_index = i;
-    else if (tiling->resolution() == LOW_RESOLUTION)
-      low_res_tiling_index = i;
-  }
-
-  iterators_.reserve(layer_->tilings_->num_tilings());
+  if (!CurrentRange().IsIndexWithinRange(CurrentTilingIndex()))
+    AdvanceRange();
 
-  // Higher resolution non-ideal goes first.
-  for (size_t i = 0; i < high_res_tiling_index; ++i) {
-    iterators_.push_back(PictureLayerTiling::TilingEvictionTileIterator(
-        layer_->tilings_->tiling_at(i), tree_priority));
-  }
-
-  // Lower resolution non-ideal goes next.
-  for (size_t i = layer_->tilings_->num_tilings() - 1;
-       i > high_res_tiling_index;
-       --i) {
-    PictureLayerTiling* tiling = layer_->tilings_->tiling_at(i);
-    if (tiling->resolution() == LOW_RESOLUTION)
-      continue;
+  iterator_ = PictureLayerTiling::TilingEvictionTileIterator(
+      layer_->tilings_->tiling_at(CurrentTilingIndex()),
+      tree_priority,
+      PriorityBinFromIterationStage(current_stage_),
+      RequiredForActivationFromIterationStage(current_stage_));
 
-    iterators_.push_back(
-        PictureLayerTiling::TilingEvictionTileIterator(tiling, tree_priority));
-  }
-
-  // Now, put the low res tiling if we have one.
-  if (low_res_tiling_index < layer_->tilings_->num_tilings()) {
-    iterators_.push_back(PictureLayerTiling::TilingEvictionTileIterator(
-        layer_->tilings_->tiling_at(low_res_tiling_index), tree_priority));
-  }
-
-  // Finally, put the high res tiling if we have one.
-  if (high_res_tiling_index < layer_->tilings_->num_tilings()) {
-    iterators_.push_back(PictureLayerTiling::TilingEvictionTileIterator(
-        layer_->tilings_->tiling_at(high_res_tiling_index), tree_priority));
-  }
-
-  DCHECK_GT(iterators_.size(), 0u);
-
-  if (!iterators_[iterator_index_] ||
-      !IsCorrectType(&iterators_[iterator_index_])) {
+  if (!iterator_)
     AdvanceToNextIterator();
-  }
 }
 
-PictureLayerImpl::LayerEvictionTileIterator::~LayerEvictionTileIterator() {}
+PictureLayerImpl::LayerEvictionTileIterator::~LayerEvictionTileIterator() {
+}
 
 Tile* PictureLayerImpl::LayerEvictionTileIterator::operator*() {
   DCHECK(*this);
-  return *iterators_[iterator_index_];
+  return *iterator_;
 }
 
 const Tile* PictureLayerImpl::LayerEvictionTileIterator::operator*() const {
   DCHECK(*this);
-  return *iterators_[iterator_index_];
+  return *iterator_;
 }
 
 PictureLayerImpl::LayerEvictionTileIterator&
 PictureLayerImpl::LayerEvictionTileIterator::
 operator++() {
   DCHECK(*this);
-  ++iterators_[iterator_index_];
-  if (!iterators_[iterator_index_] ||
-      !IsCorrectType(&iterators_[iterator_index_])) {
+  ++iterator_;
+
+  if (!iterator_)
     AdvanceToNextIterator();
-  }
   return *this;
 }
 
 void PictureLayerImpl::LayerEvictionTileIterator::AdvanceToNextIterator() {
-  ++iterator_index_;
+  DCHECK(!iterator_);
+  while (!iterator_) {
+    bool success = AdvanceTiling();
+    if (!success)
+      success = AdvanceRange();
+    if (!success)
+      success = AdvanceStage();
+    if (!success)
+      break;
 
-  while (true) {
-    while (iterator_index_ < iterators_.size()) {
-      if (iterators_[iterator_index_] &&
-          IsCorrectType(&iterators_[iterator_index_])) {
-        return;
-      }
-      ++iterator_index_;
+    iterator_ = PictureLayerTiling::TilingEvictionTileIterator(
+        layer_->tilings_->tiling_at(CurrentTilingIndex()),
+        tree_priority_,
+        PriorityBinFromIterationStage(current_stage_),
+        RequiredForActivationFromIterationStage(current_stage_));
+  }
+}
+
+bool PictureLayerImpl::LayerEvictionTileIterator::AdvanceTiling() {
+  DCHECK(CurrentRange().IsIndexWithinRange(CurrentTilingIndex()));
+  ++current_range_offset_;
+  return CurrentRange().IsIndexWithinRange(CurrentTilingIndex());
+}
+
+bool PictureLayerImpl::LayerEvictionTileIterator::AdvanceRange() {
+  DCHECK(!CurrentRange().IsIndexWithinRange(CurrentTilingIndex()));
+  bool wrapped_around = false;
+  while (!CurrentRange().IsIndexWithinRange(CurrentTilingIndex())) {
+    switch (current_tiling_range_type_) {
+      case PictureLayerTilingSet::HIGHER_THAN_HIGH_RES:
+        current_tiling_range_type_ = PictureLayerTilingSet::LOWER_THAN_LOW_RES;
+        break;
+      case PictureLayerTilingSet::LOWER_THAN_LOW_RES:
+        current_tiling_range_type_ =
+            PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES;
+        break;
+      case PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES:
+        current_tiling_range_type_ = PictureLayerTilingSet::LOW_RES;
+        break;
+      case PictureLayerTilingSet::LOW_RES:
+        current_tiling_range_type_ = PictureLayerTilingSet::HIGH_RES;
+        break;
+      case PictureLayerTilingSet::HIGH_RES:
+        current_tiling_range_type_ =
+            PictureLayerTilingSet::HIGHER_THAN_HIGH_RES;
+        wrapped_around = true;
+        break;
     }
+    current_range_offset_ = 0;
+  }
+  // If we wrapped around the ranges, we need to indicate that we should advance
+  // the stage.
+  return !wrapped_around;
+}
+
+TilePriority::PriorityBin
+PictureLayerImpl::LayerEvictionTileIterator::PriorityBinFromIterationStage(
+    IterationStage stage) {
+  switch (stage) {
+    case EVENTUALLY:
+    case EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION:
+      return TilePriority::EVENTUALLY;
+    case SOON:
+    case SOON_AND_REQUIRED_FOR_ACTIVATION:
+      return TilePriority::SOON;
+    case NOW:
+    case NOW_AND_REQUIRED_FOR_ACTIVATION:
+      return TilePriority::NOW;
+  }
+  NOTREACHED();
+  return TilePriority::EVENTUALLY;
+}
+
+bool PictureLayerImpl::LayerEvictionTileIterator::
+    RequiredForActivationFromIterationStage(IterationStage stage) {
+  switch (stage) {
+    case EVENTUALLY:
+    case SOON:
+    case NOW:
+      return false;
+    case EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION:
+    case SOON_AND_REQUIRED_FOR_ACTIVATION:
+    case NOW_AND_REQUIRED_FOR_ACTIVATION:
+      return true;
+  }
+  NOTREACHED();
+  return false;
+}
 
-    // If we're NOW and required_for_activation, then this was the last pass
-    // through the iterators.
-    if (iteration_stage_ == TilePriority::NOW && required_for_activation_)
-      break;
+PictureLayerTilingSet::TilingRange
+PictureLayerImpl::LayerEvictionTileIterator::CurrentRange() {
+  return layer_->tilings_->GetTilingRange(current_tiling_range_type_);
+}
 
-    if (!required_for_activation_) {
-      required_for_activation_ = true;
-    } else {
-      required_for_activation_ = false;
-      iteration_stage_ =
-          static_cast<TilePriority::PriorityBin>(iteration_stage_ - 1);
-    }
-    iterator_index_ = 0;
+int PictureLayerImpl::LayerEvictionTileIterator::CurrentTilingIndex() {
+  const PictureLayerTilingSet::TilingRange& range = CurrentRange();
+  switch (current_tiling_range_type_) {
+    case PictureLayerTilingSet::HIGHER_THAN_HIGH_RES:
+    case PictureLayerTilingSet::LOW_RES:
+    case PictureLayerTilingSet::HIGH_RES:
+      return range.start + current_range_offset_;
+    case PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES:
+    case PictureLayerTilingSet::LOWER_THAN_LOW_RES:
+      return static_cast<int>(range.end) - 1 - current_range_offset_;
   }
+  NOTREACHED();
+  return 0;
 }
 
-PictureLayerImpl::LayerEvictionTileIterator::operator bool() const {
-  return iterator_index_ < iterators_.size();
+bool PictureLayerImpl::LayerEvictionTileIterator::AdvanceStage() {
+  switch (current_stage_) {
+    case EVENTUALLY:
+      current_stage_ = EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION;
+      break;
+    case EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION:
+      current_stage_ = SOON;
+      break;
+    case SOON:
+      current_stage_ = SOON_AND_REQUIRED_FOR_ACTIVATION;
+      break;
+    case SOON_AND_REQUIRED_FOR_ACTIVATION:
+      current_stage_ = NOW;
+      break;
+    case NOW:
+      current_stage_ = NOW_AND_REQUIRED_FOR_ACTIVATION;
+      break;
+    case NOW_AND_REQUIRED_FOR_ACTIVATION:
+      return false;
+  }
+  return true;
 }
 
-bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
-    PictureLayerTiling::TilingEvictionTileIterator* it) const {
-  return it->get_type() == iteration_stage_ &&
-         (**it)->required_for_activation() == required_for_activation_;
+PictureLayerImpl::LayerEvictionTileIterator::operator bool() const {
+  return !!iterator_;
 }
 
 }  // namespace cc

cc/layers/picture_layer_impl.h

@@ -77,15 +77,33 @@ class CC_EXPORT PictureLayerImpl
     operator bool() const;
 
    private:
+    enum IterationStage {
+      EVENTUALLY,
+      EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION,
+      SOON,
+      SOON_AND_REQUIRED_FOR_ACTIVATION,
+      NOW,
+      NOW_AND_REQUIRED_FOR_ACTIVATION
+    };
+
+    TilePriority::PriorityBin PriorityBinFromIterationStage(
+        IterationStage stage);
+    bool RequiredForActivationFromIterationStage(IterationStage stage);
+
+    PictureLayerTilingSet::TilingRange CurrentRange();
+    int CurrentTilingIndex();
+
     void AdvanceToNextIterator();
-    bool IsCorrectType(
-        PictureLayerTiling::TilingEvictionTileIterator* it) const;
+    bool AdvanceTiling();
+    bool AdvanceRange();
+    bool AdvanceStage();
 
-    std::vector<PictureLayerTiling::TilingEvictionTileIterator> iterators_;
-    size_t iterator_index_;
-    TilePriority::PriorityBin iteration_stage_;
-    bool required_for_activation_;
+    PictureLayerTiling::TilingEvictionTileIterator iterator_;
+    int current_range_offset_;
+    PictureLayerTilingSet::TilingRangeType current_tiling_range_type_;
+    IterationStage current_stage_;
 
+    TreePriority tree_priority_;
     PictureLayerImpl* layer_;
   };
 

cc/resources/picture_layer_tiling.cc

@@ -845,17 +845,48 @@ void PictureLayerTiling::UpdateEvictionCacheIfNeeded(
       eviction_cache_tree_priority_ == tree_priority)
     return;
 
-  eviction_tiles_cache_.clear();
-  eviction_tiles_cache_.reserve(tiles_.size());
+  eventually_eviction_tiles_.clear();
+  soon_eviction_tiles_.clear();
+  now_required_for_activation_eviction_tiles_.clear();
+  now_not_required_for_activation_eviction_tiles_.clear();
+
   for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     // TODO(vmpstr): This should update the priority if UpdateTilePriorities
     // changes not to do this.
-    eviction_tiles_cache_.push_back(it->second);
+    Tile* tile = it->second;
+    const TilePriority& priority =
+        tile->priority_for_tree_priority(tree_priority);
+    switch (priority.priority_bin) {
+      case TilePriority::EVENTUALLY:
+        eventually_eviction_tiles_.push_back(tile);
+        break;
+      case TilePriority::SOON:
+        soon_eviction_tiles_.push_back(tile);
+        break;
+      case TilePriority::NOW:
+        if (tile->required_for_activation())
+          now_required_for_activation_eviction_tiles_.push_back(tile);
+        else
+          now_not_required_for_activation_eviction_tiles_.push_back(tile);
+        break;
+    }
   }
 
-  std::sort(eviction_tiles_cache_.begin(),
-            eviction_tiles_cache_.end(),
-            TileEvictionOrder(tree_priority));
+  // TODO(vmpstr): Do this lazily. One option is to have a "sorted" flag that
+  // can be updated for each of the queues.
+  TileEvictionOrder sort_order(tree_priority);
+  std::sort(eventually_eviction_tiles_.begin(),
+            eventually_eviction_tiles_.end(),
+            sort_order);
+  std::sort(
+      soon_eviction_tiles_.begin(), soon_eviction_tiles_.end(), sort_order);
+  std::sort(now_required_for_activation_eviction_tiles_.begin(),
+            now_required_for_activation_eviction_tiles_.end(),
+            sort_order);
+  std::sort(now_not_required_for_activation_eviction_tiles_.begin(),
+            now_not_required_for_activation_eviction_tiles_.end(),
+            sort_order);
+
   eviction_tiles_cache_valid_ = true;
   eviction_cache_tree_priority_ = tree_priority;
 }
@@ -985,16 +1016,37 @@ operator++() {
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator()
-    : tiling_(NULL) {
+    : tiling_(NULL), eviction_tiles_(NULL) {
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
     PictureLayerTiling* tiling,
-    TreePriority tree_priority)
-    : tiling_(tiling), tree_priority_(tree_priority) {
+    TreePriority tree_priority,
+    TilePriority::PriorityBin type,
+    bool required_for_activation)
+    : tiling_(tiling), tree_priority_(tree_priority), eviction_tiles_(NULL) {
+  if (required_for_activation && type != TilePriority::NOW)
+    return;
+
   tiling_->UpdateEvictionCacheIfNeeded(tree_priority_);
-  tile_iterator_ = tiling_->eviction_tiles_cache_.begin();
-  if (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
+  switch (type) {
+    case TilePriority::EVENTUALLY:
+      eviction_tiles_ = &tiling_->eventually_eviction_tiles_;
+      break;
+    case TilePriority::SOON:
+      eviction_tiles_ = &tiling_->soon_eviction_tiles_;
+      break;
+    case TilePriority::NOW:
+      if (required_for_activation)
+        eviction_tiles_ = &tiling_->now_required_for_activation_eviction_tiles_;
+      else
+        eviction_tiles_ =
+            &tiling_->now_not_required_for_activation_eviction_tiles_;
+      break;
+  }
+  DCHECK(eviction_tiles_);
+  tile_iterator_ = eviction_tiles_->begin();
+  if (tile_iterator_ != eviction_tiles_->end() &&
       !(*tile_iterator_)->HasResources()) {
     ++(*this);
   }
@@ -1003,7 +1055,7 @@ PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
 PictureLayerTiling::TilingEvictionTileIterator::~TilingEvictionTileIterator() {}
 
 PictureLayerTiling::TilingEvictionTileIterator::operator bool() const {
-  return tiling_ && tile_iterator_ != tiling_->eviction_tiles_cache_.end();
+  return eviction_tiles_ && tile_iterator_ != eviction_tiles_->end();
 }
 
 Tile* PictureLayerTiling::TilingEvictionTileIterator::operator*() {
@@ -1022,7 +1074,7 @@ operator++() {
   DCHECK(*this);
   do {
     ++tile_iterator_;
-  } while (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
+  } while (tile_iterator_ != eviction_tiles_->end() &&
            (!(*tile_iterator_)->HasResources()));
 
   return *this;

cc/resources/picture_layer_tiling.h

@@ -108,24 +108,21 @@ class CC_EXPORT PictureLayerTiling {
    public:
     TilingEvictionTileIterator();
     TilingEvictionTileIterator(PictureLayerTiling* tiling,
-                               TreePriority tree_priority);
+                               TreePriority tree_priority,
+                               TilePriority::PriorityBin type,
+                               bool required_for_activation);
     ~TilingEvictionTileIterator();
 
     operator bool() const;
     const Tile* operator*() const;
     Tile* operator*();
     TilingEvictionTileIterator& operator++();
-    TilePriority::PriorityBin get_type() {
-      DCHECK(*this);
-      const TilePriority& priority =
-          (*tile_iterator_)->priority_for_tree_priority(tree_priority_);
-      return priority.priority_bin;
-    }
 
    private:
     PictureLayerTiling* tiling_;
     TreePriority tree_priority_;
     std::vector<Tile*>::iterator tile_iterator_;
+    std::vector<Tile*>* eviction_tiles_;
   };
 
   ~PictureLayerTiling();
@@ -326,7 +323,10 @@ class CC_EXPORT PictureLayerTiling {
   bool has_soon_border_rect_tiles_;
   bool has_eventually_rect_tiles_;
 
-  std::vector<Tile*> eviction_tiles_cache_;
+  std::vector<Tile*> eventually_eviction_tiles_;
+  std::vector<Tile*> soon_eviction_tiles_;
+  std::vector<Tile*> now_required_for_activation_eviction_tiles_;
+  std::vector<Tile*> now_not_required_for_activation_eviction_tiles_;
   bool eviction_tiles_cache_valid_;
   TreePriority eviction_cache_tree_priority_;
 

cc/resources/picture_layer_tiling_perftest.cc

@@ -202,7 +202,10 @@ class PictureLayerTilingPerfTest : public testing::Test {
     int priority_count = 0;
     do {
       PictureLayerTiling::TilingEvictionTileIterator it(
-          picture_layer_tiling_.get(), priorities[priority_count]);
+          picture_layer_tiling_.get(),
+          priorities[priority_count],
+          TilePriority::NOW,
+          false);
       priority_count = (priority_count + 1) % arraysize(priorities);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
@@ -246,7 +249,10 @@ class PictureLayerTilingPerfTest : public testing::Test {
     do {
       int count = num_tiles;
       PictureLayerTiling::TilingEvictionTileIterator it(
-          picture_layer_tiling_.get(), priorities[priority_count]);
+          picture_layer_tiling_.get(),
+          priorities[priority_count],
+          TilePriority::EVENTUALLY,
+          false);
       while (count--) {
         ASSERT_TRUE(it) << "count: " << count;
         ASSERT_TRUE(*it != NULL) << "count: " << count;

cc/resources/picture_layer_tiling_set.h

@@ -30,6 +30,10 @@ class CC_EXPORT PictureLayerTilingSet {
   struct TilingRange {
     TilingRange(size_t start, size_t end) : start(start), end(end) {}
 
+    bool IsIndexWithinRange(size_t index) const {
+      return index >= start && index < end;
+    }
+
     size_t start;
     size_t end;
   };

cc/resources/picture_layer_tiling_unittest.cc

@@ -1042,7 +1042,7 @@ TEST(PictureLayerTilingTest, TilingEvictionTileIteratorStaticViewport) {
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(50, 50, 100, 100);
-  gfx::Size layer_bounds(200, 200);
+  gfx::Size layer_bounds(2000, 2000);
 
   client.SetTileSize(gfx::Size(30, 30));
   client.set_tree(ACTIVE_TREE);
@@ -1056,39 +1056,59 @@ TEST(PictureLayerTilingTest, TilingEvictionTileIteratorStaticViewport) {
 
   std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
 
-  PictureLayerTiling::TilingEvictionTileIterator it(tiling.get(),
-                                                    SMOOTHNESS_TAKES_PRIORITY);
+  PictureLayerTiling::TilingEvictionTileIterator it(
+      tiling.get(), SMOOTHNESS_TAKES_PRIORITY, TilePriority::NOW, false);
 
   // Tiles don't have resources to evict.
   EXPECT_FALSE(it);
 
   // Sanity check.
-  EXPECT_EQ(64u, all_tiles.size());
+  EXPECT_EQ(5184u, all_tiles.size());
 
   client.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
 
   std::set<Tile*> all_tiles_set(all_tiles.begin(), all_tiles.end());
 
+  std::set<Tile*> eviction_tiles;
+
   it = PictureLayerTiling::TilingEvictionTileIterator(
-      tiling.get(), SMOOTHNESS_TAKES_PRIORITY);
+      tiling.get(), SMOOTHNESS_TAKES_PRIORITY, TilePriority::EVENTUALLY, false);
   EXPECT_TRUE(it);
+  for (; it; ++it) {
+    Tile* tile = *it;
+    EXPECT_TRUE(tile);
+    EXPECT_EQ(TilePriority::EVENTUALLY,
+              tile->priority(ACTIVE_TREE).priority_bin);
+    EXPECT_FALSE(tile->required_for_activation());
+    eviction_tiles.insert(tile);
+  }
 
-  std::set<Tile*> eviction_tiles;
-  Tile* last_tile = *it;
+  it = PictureLayerTiling::TilingEvictionTileIterator(
+      tiling.get(), SMOOTHNESS_TAKES_PRIORITY, TilePriority::SOON, false);
+  EXPECT_TRUE(it);
   for (; it; ++it) {
     Tile* tile = *it;
     EXPECT_TRUE(tile);
-    EXPECT_LE(tile->priority(ACTIVE_TREE).priority_bin,
-              last_tile->priority(ACTIVE_TREE).priority_bin);
-    if (tile->priority(ACTIVE_TREE).priority_bin ==
-        last_tile->priority(ACTIVE_TREE).priority_bin) {
-      EXPECT_LE(tile->priority(ACTIVE_TREE).distance_to_visible,
-                last_tile->priority(ACTIVE_TREE).distance_to_visible);
-    }
-    last_tile = tile;
+    EXPECT_EQ(TilePriority::SOON, tile->priority(ACTIVE_TREE).priority_bin);
+    EXPECT_FALSE(tile->required_for_activation());
     eviction_tiles.insert(tile);
   }
 
+  it = PictureLayerTiling::TilingEvictionTileIterator(
+      tiling.get(), SMOOTHNESS_TAKES_PRIORITY, TilePriority::NOW, false);
+  EXPECT_TRUE(it);
+  for (; it; ++it) {
+    Tile* tile = *it;
+    EXPECT_TRUE(tile);
+    EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
+    EXPECT_FALSE(tile->required_for_activation());
+    eviction_tiles.insert(tile);
+  }
+
+  it = PictureLayerTiling::TilingEvictionTileIterator(
+      tiling.get(), SMOOTHNESS_TAKES_PRIORITY, TilePriority::NOW, true);
+  EXPECT_FALSE(it);
+
   EXPECT_GT(all_tiles_set.size(), 0u);
   EXPECT_EQ(all_tiles_set, eviction_tiles);
 }