cc: Start using raster/eviction iterators.

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>
 
@@ skipping 35 matching lines @@
       return a_is_occluded;
 
     // Or if a is farther away from visible.
     return a_priority.distance_to_visible > b_priority.distance_to_visible;
   }
 
  private:
   TreePriority tree_priority_;
 };
 
-void ReleaseTile(Tile* tile, WhichTree tree) {
-  // Reset priority as tile is ref-counted and might still be used
-  // even though we no longer hold a reference to it here anymore.
-  tile->SetPriority(tree, TilePriority());
-}
-
 }  // namespace
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
     float contents_scale,
     const gfx::Size& layer_bounds,
     PictureLayerTilingClient* client) {
   return make_scoped_ptr(new PictureLayerTiling(contents_scale,
                                                 layer_bounds,
                                                 client));
 }
 
 PictureLayerTiling::PictureLayerTiling(float contents_scale,
                                        const gfx::Size& layer_bounds,
                                        PictureLayerTilingClient* client)
     : contents_scale_(contents_scale),
       layer_bounds_(layer_bounds),
       resolution_(NON_IDEAL_RESOLUTION),
       client_(client),
       tiling_data_(gfx::Size(), gfx::Size(), true),
       last_impl_frame_time_in_seconds_(0.0),
+      content_to_screen_scale_(1.0f),
       has_visible_rect_tiles_(false),
       has_skewport_rect_tiles_(false),
       has_soon_border_rect_tiles_(false),
       has_eventually_rect_tiles_(false),
       eviction_tiles_cache_valid_(false),
       eviction_cache_tree_priority_(SAME_PRIORITY_FOR_BOTH_TREES) {
   gfx::Size content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale));
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
 
   DCHECK(!gfx::ToFlooredSize(
       gfx::ScaleSize(layer_bounds, contents_scale)).IsEmpty()) <<
       "Tiling created with scale too small as contents become empty." <<
       " Layer bounds: " << layer_bounds.ToString() <<
       " Contents scale: " << contents_scale;
 
   tiling_data_.SetTilingSize(content_bounds);
   tiling_data_.SetMaxTextureSize(tile_size);
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
-  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-    ReleaseTile(it->second.get(), client_->GetTree());
 }
 
 void PictureLayerTiling::SetClient(PictureLayerTilingClient* client) {
   client_ = client;
 }
 
 Tile* PictureLayerTiling::CreateTile(int i,
                                      int j,
                                      const PictureLayerTiling* twin_tiling) {
   TileMapKey key(i, j);
   DCHECK(tiles_.find(key) == tiles_.end());
 
   gfx::Rect paint_rect = tiling_data_.TileBoundsWithBorder(i, j);
   gfx::Rect tile_rect = paint_rect;
   tile_rect.set_size(tiling_data_.max_texture_size());
 
   // Check our twin for a valid tile.
   if (twin_tiling &&
       tiling_data_.max_texture_size() ==
       twin_tiling->tiling_data_.max_texture_size()) {
     if (Tile* candidate_tile = twin_tiling->TileAt(i, j)) {
       gfx::Rect rect =
           gfx::ScaleToEnclosingRect(paint_rect, 1.0f / contents_scale_);
       if (!client_->GetInvalidation()->Intersects(rect)) {
+        DCHECK_EQ(i, candidate_tile->tiling_i_index());
+        DCHECK_EQ(j, candidate_tile->tiling_j_index());
         tiles_[key] = candidate_tile;
         return candidate_tile;
       }
     }
   }
 
   // Create a new tile because our twin didn't have a valid one.
   scoped_refptr<Tile> tile = client_->CreateTile(this, tile_rect);
-  if (tile.get())
+  if (tile.get()) {
+    tile->set_tiling_index(i, j);
     tiles_[key] = tile;
+  }
   return tile.get();
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
   const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
   bool include_borders = true;
   for (TilingData::Iterator iter(
            &tiling_data_, live_tiles_rect_, include_borders);
        iter;
        ++iter) {
@@ skipping 67 matching lines @@
     bool include_borders = true;
     for (TilingData::Iterator iter(
              &tiling_data_, content_rect, include_borders);
          iter;
          ++iter) {
       TileMapKey key(iter.index());
       TileMap::iterator find = tiles_.find(key);
       if (find == tiles_.end())
         continue;
 
-      ReleaseTile(find->second.get(), client_->GetTree());
-
       tiles_.erase(find);
       new_tile_keys.push_back(key);
     }
   }
 
   if (recreate_invalidated_tiles && !new_tile_keys.empty()) {
     for (size_t i = 0; i < new_tile_keys.size(); ++i) {
       // Don't try to share a tile with the twin layer, it's been invalidated so
       // we have to make our own tile here.
       const PictureLayerTiling* twin_tiling = NULL;
@@ skipping 147 matching lines @@
 
   return texture_rect;
 }
 
 gfx::Size PictureLayerTiling::CoverageIterator::texture_size() const {
   return tiling_->tiling_data_.max_texture_size();
 }
 
 void PictureLayerTiling::Reset() {
   live_tiles_rect_ = gfx::Rect();
-  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-    ReleaseTile(it->second.get(), client_->GetTree());
   tiles_.clear();
 }
 
 gfx::Rect PictureLayerTiling::ComputeSkewport(
     double current_frame_time_in_seconds,
     const gfx::Rect& visible_rect_in_content_space) const {
   gfx::Rect skewport = visible_rect_in_content_space;
   if (last_impl_frame_time_in_seconds_ == 0.0)
     return skewport;
 
@@ skipping 54 matching lines @@
 
   gfx::Rect visible_rect_in_content_space =
       gfx::ScaleToEnclosingRect(visible_layer_rect, contents_scale_);
 
   if (tiling_size().IsEmpty()) {
     last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
     last_visible_rect_in_content_space_ = visible_rect_in_content_space;
     return;
   }
 
+  // Calculate the skewport.
+  gfx::Rect skewport = ComputeSkewport(current_frame_time_in_seconds,
+                                       visible_rect_in_content_space);
+  DCHECK(skewport.Contains(visible_rect_in_content_space));
+
+  // Calculate the eventually/live tiles rect.
   size_t max_tiles_for_interest_area = client_->GetMaxTilesForInterestArea();
 
   gfx::Size tile_size = tiling_data_.max_texture_size();
   int64 eventually_rect_area =
       max_tiles_for_interest_area * tile_size.width() * tile_size.height();
 
-  gfx::Rect skewport = ComputeSkewport(current_frame_time_in_seconds,
-                                       visible_rect_in_content_space);
-  DCHECK(skewport.Contains(visible_rect_in_content_space));
-
   gfx::Rect eventually_rect =
       ExpandRectEquallyToAreaBoundedBy(visible_rect_in_content_space,
                                        eventually_rect_area,
                                        gfx::Rect(tiling_size()),
                                        &expansion_cache_);
 
   DCHECK(eventually_rect.IsEmpty() ||
          gfx::Rect(tiling_size()).Contains(eventually_rect))
       << "tiling_size: " << tiling_size().ToString()
       << " eventually_rect: " << eventually_rect.ToString();
 
+  // Calculate the soon border rect.
+  content_to_screen_scale_ = 1.0f / (contents_scale_ * ideal_contents_scale);

[USE eero AT chromium.org, 2014/08/19 08:40:20]

This should be
  content_to_screen_scale_ = ideal_contents_scale / contents_scale_;
in order not to reintroduce bug 403829 fixed in
https://codereview.chromium.org/478723002

[vmpstr, 2014/08/19 18:04:33]

Good point, I'll rebase.

+  gfx::Rect soon_border_rect = visible_rect_in_content_space;
+  float border = kSoonBorderDistanceInScreenPixels / content_to_screen_scale_;
+  soon_border_rect.Inset(-border, -border, -border, -border);
+
+  // Update the tiling state.
   SetLiveTilesRect(eventually_rect);
 
   last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
   last_visible_rect_in_content_space_ = visible_rect_in_content_space;
 
   eviction_tiles_cache_valid_ = false;
 
-  TilePriority now_priority(resolution_, TilePriority::NOW, 0);
-  float content_to_screen_scale =
-      1.0f / (contents_scale_ * ideal_contents_scale);
-
-  // Assign now priority to all visible tiles.
-  bool include_borders = true;
-  has_visible_rect_tiles_ = false;
-  for (TilingData::Iterator iter(
-           &tiling_data_, visible_rect_in_content_space, include_borders);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
-      continue;
-    has_visible_rect_tiles_ = true;
-    Tile* tile = find->second.get();
-
-    tile->SetPriority(tree, now_priority);
-
-    // Set whether tile is occluded or not.
-    bool is_occluded = false;
-    if (occlusion_tracker) {
-      gfx::Rect tile_query_rect = ScaleToEnclosingRect(
-          IntersectRects(tile->content_rect(), visible_rect_in_content_space),
-          1.0f / contents_scale_);
-      // TODO(vmpstr): Remove render_target and draw_transform from the
-      // parameters so they can be hidden from the tiling.
-      is_occluded = occlusion_tracker->Occluded(
-          render_target, tile_query_rect, draw_transform);
-    }
-    tile->set_is_occluded(tree, is_occluded);
-  }
-
-  // Assign soon priority to skewport tiles.
-  has_skewport_rect_tiles_ = false;
-  for (TilingData::DifferenceIterator iter(
-           &tiling_data_, skewport, visible_rect_in_content_space);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
-      continue;
-    has_skewport_rect_tiles_ = true;
-    Tile* tile = find->second.get();
-
-    gfx::Rect tile_bounds =
-        tiling_data_.TileBounds(iter.index_x(), iter.index_y());
-
-    float distance_to_visible =
-        visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
-        content_to_screen_scale;
-
-    TilePriority priority(resolution_, TilePriority::SOON, distance_to_visible);
-    tile->SetPriority(tree, priority);
-  }
-
-  // Assign eventually priority to interest rect tiles.
-  has_eventually_rect_tiles_ = false;
-  for (TilingData::DifferenceIterator iter(
-           &tiling_data_, eventually_rect, skewport);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
-      continue;
-    has_eventually_rect_tiles_ = true;
-    Tile* tile = find->second.get();
-
-    gfx::Rect tile_bounds =
-        tiling_data_.TileBounds(iter.index_x(), iter.index_y());
-
-    float distance_to_visible =
-        visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
-        content_to_screen_scale;
-    TilePriority priority(
-        resolution_, TilePriority::EVENTUALLY, distance_to_visible);
-    tile->SetPriority(tree, priority);
-  }
-
-  // Upgrade the priority on border tiles to be SOON.
-  gfx::Rect soon_border_rect = visible_rect_in_content_space;
-  float border = kSoonBorderDistanceInScreenPixels / content_to_screen_scale;
-  soon_border_rect.Inset(-border, -border, -border, -border);
-  has_soon_border_rect_tiles_ = false;
-  for (TilingData::DifferenceIterator iter(
-           &tiling_data_, soon_border_rect, skewport);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
-      continue;
-    has_soon_border_rect_tiles_ = true;
-    Tile* tile = find->second.get();
-
-    TilePriority priority(resolution_,
-                          TilePriority::SOON,
-                          tile->priority(tree).distance_to_visible);
-    tile->SetPriority(tree, priority);
-  }
-
   // Update iteration rects.
   current_visible_rect_ = visible_rect_in_content_space;
   current_skewport_rect_ = skewport;
   current_soon_border_rect_ = soon_border_rect;
   current_eventually_rect_ = eventually_rect;
+
+  // Update has_*_tiles state.
+  const gfx::Rect& tiling_rect = gfx::Rect(tiling_size());
+
+  has_visible_rect_tiles_ = tiling_rect.Intersects(current_visible_rect_);
+  has_skewport_rect_tiles_ = tiling_rect.Intersects(current_skewport_rect_);
+  has_soon_border_rect_tiles_ =
+      tiling_rect.Intersects(current_soon_border_rect_);
+  has_eventually_rect_tiles_ = tiling_rect.Intersects(current_eventually_rect_);
+
+  // Update occlusion.
+  occlusion_set_.clear();
+  if (occlusion_tracker) {
+    bool include_borders = true;
+    for (TilingData::Iterator iter(
+             &tiling_data_, visible_rect_in_content_space, include_borders);
+         iter;
+         ++iter) {
+      gfx::Rect paint_rect =
+          tiling_data_.TileBoundsWithBorder(iter.index_x(), iter.index_y());
+      gfx::Rect tile_rect = paint_rect;
+      tile_rect.set_size(tiling_data_.max_texture_size());
+      gfx::Rect tile_query_rect = ScaleToEnclosingRect(
+          IntersectRects(tile_rect, visible_rect_in_content_space),
+          1.0f / contents_scale_);
+      bool is_occluded = occlusion_tracker->Occluded(
+          render_target, tile_query_rect, draw_transform);
+      if (!is_occluded)
+        continue;
+      occlusion_set_.insert(iter.index());
+    }
+  }
 }
 
 void PictureLayerTiling::SetLiveTilesRect(
     const gfx::Rect& new_live_tiles_rect) {
   DCHECK(new_live_tiles_rect.IsEmpty() ||
          gfx::Rect(tiling_size()).Contains(new_live_tiles_rect))
       << "tiling_size: " << tiling_size().ToString()
       << " new_live_tiles_rect: " << new_live_tiles_rect.ToString();
   if (live_tiles_rect_ == new_live_tiles_rect)
     return;
 
   // Iterate to delete all tiles outside of our new live_tiles rect.
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            live_tiles_rect_,
                                            new_live_tiles_rect);
        iter;
        ++iter) {
     TileMapKey key(iter.index());
     TileMap::iterator found = tiles_.find(key);
     // If the tile was outside of the recorded region, it won't exist even
     // though it was in the live rect.
-    if (found != tiles_.end()) {
-      ReleaseTile(found->second.get(), client_->GetTree());
+    if (found != tiles_.end())
       tiles_.erase(found);
-    }
   }
 
   const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
 
   // Iterate to allocate new tiles for all regions with newly exposed area.
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            new_live_tiles_rect,
                                            live_tiles_rect_);
        iter;
        ++iter) {
     TileMapKey key(iter.index());
     CreateTile(key.first, key.second, twin_tiling);
   }
 
   live_tiles_rect_ = new_live_tiles_rect;
 }
 
-void PictureLayerTiling::DidBecomeRecycled() {
-  // DidBecomeActive below will set the active priority for tiles that are
-  // still in the tree. Calling this first on an active tiling that is becoming
-  // recycled takes care of tiles that are no longer in the active tree (eg.
-  // due to a pending invalidation).
-  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
-    it->second->SetPriority(ACTIVE_TREE, TilePriority());
-  }
+bool PictureLayerTiling::IsTileOccluded(const Tile* tile) const {
+  DCHECK(tile);
+  bool is_occluded = occlusion_set_.count(std::make_pair(
+                         tile->tiling_i_index(), tile->tiling_j_index())) != 0;
+  return is_occluded;
 }
 
-void PictureLayerTiling::DidBecomeActive() {
-  PicturePileImpl* active_pile = client_->GetPile();
-  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
-    it->second->SetPriority(ACTIVE_TREE, it->second->priority(PENDING_TREE));
-    it->second->SetPriority(PENDING_TREE, TilePriority());
+bool PictureLayerTiling::IsTileRequiredForActivation(const Tile* tile) const {
+  if (resolution_ != HIGH_RESOLUTION)
+    return false;
 
-    // Tile holds a ref onto a picture pile. If the tile never gets invalidated
-    // and recreated, then that picture pile ref could exist indefinitely.  To
-    // prevent this, ask the client to update the pile to its own ref.  This
-    // will cause PicturePileImpls and their clones to get deleted once the
-    // corresponding PictureLayerImpl and any in flight raster jobs go out of
-    // scope.
-    it->second->set_picture_pile(active_pile);
+  WhichTree tree = client_->GetTree();
+  if (tree != PENDING_TREE)
+    return false;
+
+  if (IsTileOccluded(tile))
+    return false;
+
+  if (client_->RequiresHighResToDraw())
+    return true;
+
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
+  if (!twin_tiling)
+    return true;
+
+  if (twin_tiling->layer_bounds() != layer_bounds())
+    return true;
+
+  if (twin_tiling->current_visible_rect_ != current_visible_rect_)
+    return true;
+
+  Tile* twin_tile =
+      twin_tiling->TileAt(tile->tiling_i_index(), tile->tiling_j_index());

[danakj, 2014/08/18 19:29:13]

:( We do this every time we want to see if we can activate, for every tile in
the visible content rect. This involves hash map lookups, and I feel like this
is going to be crap for performance. Did you experience otherwise?

Perhaps we could investigate having the Tile know if it's shared?

[vmpstr, 2014/08/18 19:49:52]

I'll do this in a separate patch. 

+  if (!twin_tile || twin_tile == tile)
+    return false;
+
+  return true;
+}
+
+void PictureLayerTiling::UpdateTileAndTwinPriority(Tile* tile) const {
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
+  if (twin_tiling)
+    twin_tiling->UpdateTilePriority(tile);
+  UpdateTilePriority(tile);
+}
+
+void PictureLayerTiling::UpdateTilePriority(Tile* tile) const {
+  WhichTree tree = client_->GetTree();
+
+  if (tree == PENDING_TREE)
+    tile->set_required_for_activation(false);
+  tile->set_is_occluded(tree, false);
+
+  if (TileAt(tile->tiling_i_index(), tile->tiling_j_index()) != tile) {
+    tile->SetPriority(tree, TilePriority());
+    return;
   }
+
+  gfx::Rect tile_bounds = tiling_data_.TileBoundsWithBorder(
+      tile->tiling_i_index(), tile->tiling_j_index());
+
+  if (current_visible_rect_.Intersects(tile_bounds)) {
+    tile->SetPriority(tree, TilePriority(resolution_, TilePriority::NOW, 0));
+    if (tree == PENDING_TREE)
+      tile->set_required_for_activation(IsTileRequiredForActivation(tile));
+    tile->set_is_occluded(tree, IsTileOccluded(tile));
+    return;
+  }
+
+  float distance_to_visible =
+      current_visible_rect_.ManhattanInternalDistance(tile_bounds) *
+      content_to_screen_scale_;
+
+  if (current_soon_border_rect_.Intersects(tile_bounds) ||
+      current_skewport_rect_.Intersects(tile_bounds)) {
+    tile->SetPriority(
+        tree,
+        TilePriority(resolution_, TilePriority::SOON, distance_to_visible));
+    return;
+  }
+
+  tile->SetPriority(
+      tree,
+      TilePriority(resolution_, TilePriority::EVENTUALLY, distance_to_visible));
 }
 
 void PictureLayerTiling::AsValueInto(base::debug::TracedValue* state) const {
   state->SetInteger("num_tiles", tiles_.size());
   state->SetDouble("content_scale", contents_scale_);
   state->BeginDictionary("tiling_size");
   MathUtil::AddToTracedValue(tiling_size(), state);
   state->EndDictionary();
 }
 
@@ skipping 162 matching lines @@
     return;
 
   eviction_tiles_now_.clear();
   eviction_tiles_now_and_rfa_.clear();
   eviction_tiles_soon_.clear();
   eviction_tiles_soon_and_rfa_.clear();
   eviction_tiles_eventually_.clear();
   eviction_tiles_eventually_and_rfa_.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.
     Tile* tile = it->second;
+    UpdateTileAndTwinPriority(tile);
     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_rfa_.push_back(tile);
         else
           eviction_tiles_eventually_.push_back(tile);
         break;
       case TilePriority::SOON:
@@ skipping 71 matching lines @@
   visible_iterator_ = TilingData::Iterator(&tiling_->tiling_data_,
                                            tiling_->current_visible_rect_,
                                            true /* include_borders */);
   if (!visible_iterator_) {
     AdvancePhase();
     return;
   }
 
   current_tile_ =
       tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y());
-  if (!current_tile_ || !TileNeedsRaster(current_tile_))
+  if (!current_tile_ || !TileNeedsRaster(current_tile_)) {
     ++(*this);
+    return;
+  }
+  tiling_->UpdateTileAndTwinPriority(current_tile_);
 }
 
 PictureLayerTiling::TilingRasterTileIterator::~TilingRasterTileIterator() {}
 
 void PictureLayerTiling::TilingRasterTileIterator::AdvancePhase() {
   DCHECK_LT(phase_, EVENTUALLY_RECT);
 
   do {
     phase_ = static_cast<Phase>(phase_ + 1);
     switch (phase_) {
@@ skipping 40 matching lines @@
       if (current_tile_ && TileNeedsRaster(current_tile_))
         break;
       ++spiral_iterator_;
     }
 
     if (!spiral_iterator_ && phase_ == EVENTUALLY_RECT) {
       current_tile_ = NULL;
       break;
     }
   } while (!spiral_iterator_);
+
+  if (current_tile_)
+    tiling_->UpdateTileAndTwinPriority(current_tile_);
 }
 
 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 17 matching lines @@
         ++spiral_iterator_;
         if (!spiral_iterator_) {
           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_);
   return *this;
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator()
     : eviction_tiles_(NULL), current_eviction_tiles_index_(0u) {
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
     PictureLayerTiling* tiling,
     TreePriority tree_priority,
@@ skipping 30 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