cc: Use reverse spiral iterator in tiling 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 78712a2c237f6f1aa80bd730dde4694d3220448c..0a47be59eadc7da0a1d598a54c4ec722e6bd4780 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -25,35 +25,6 @@ namespace {
 
 const float kSoonBorderDistanceInScreenPixels = 312.f;
 
-class TileEvictionOrder {
- public:
-  explicit TileEvictionOrder(TreePriority tree_priority)
-      : tree_priority_(tree_priority) {}
-  ~TileEvictionOrder() {}
-
-  bool operator()(const Tile* a, const Tile* b) {
-    const TilePriority& a_priority =
-        a->priority_for_tree_priority(tree_priority_);
-    const TilePriority& b_priority =
-        b->priority_for_tree_priority(tree_priority_);
-
-    DCHECK(a_priority.priority_bin == b_priority.priority_bin);
-    DCHECK(a->required_for_activation() == b->required_for_activation());
-
-    // Or if a is occluded and b is unoccluded.
-    bool a_is_occluded = a->is_occluded_for_tree_priority(tree_priority_);
-    bool b_is_occluded = b->is_occluded_for_tree_priority(tree_priority_);
-    if (a_is_occluded != b_is_occluded)
-      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_;
-};
-
 }  // namespace
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
@@ -79,9 +50,7 @@ PictureLayerTiling::PictureLayerTiling(float contents_scale,
       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) {
+      has_eventually_rect_tiles_(false) {
   gfx::Size content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale));
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
@@ -145,7 +114,6 @@ Tile* PictureLayerTiling::CreateTile(int i,
     tile->set_tiling_index(i, j);
     tiles_[key] = tile;
   }
-  eviction_tiles_cache_valid_ = false;
   return tile.get();
 }
 
@@ -470,7 +438,6 @@ bool PictureLayerTiling::RemoveTileAt(int i,
     return false;
   found->second->set_shared(false);
   tiles_.erase(found);
-  eviction_tiles_cache_valid_ = false;
   if (recycled_twin) {
     // Recycled twin does not also have a recycled twin, so pass NULL.
     recycled_twin->RemoveTileAt(i, j, NULL);
@@ -487,7 +454,6 @@ void PictureLayerTiling::Reset() {
       recycled_twin->RemoveTileAt(it->first.first, it->first.second, NULL);
   }
   tiles_.clear();
-  eviction_tiles_cache_valid_ = false;
 }
 
 gfx::Rect PictureLayerTiling::ComputeSkewport(
@@ -597,8 +563,6 @@ void PictureLayerTiling::ComputeTilePriorityRects(
   last_viewport_in_layer_space_ = viewport_in_layer_space;
   last_visible_rect_in_content_space_ = visible_rect_in_content_space;
 
-  eviction_tiles_cache_valid_ = false;
-
   current_visible_rect_ = visible_rect_in_content_space;
   current_skewport_rect_ = skewport;
   current_soon_border_rect_ = soon_border_rect;
@@ -997,92 +961,6 @@ gfx::Rect PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
   return result;
 }
 
-void PictureLayerTiling::UpdateEvictionCacheIfNeeded(
-    TreePriority tree_priority) {
-  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);
-    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;
-      case TilePriority::SOON:
-        if (tile->required_for_activation())
-          eviction_tiles_soon_and_required_for_activation_.push_back(tile);
-        else
-          eviction_tiles_soon_.push_back(tile);
-        break;
-      case TilePriority::NOW:
-        if (tile->required_for_activation())
-          eviction_tiles_now_and_required_for_activation_.push_back(tile);
-        else
-          eviction_tiles_now_.push_back(tile);
-        break;
-    }
-  }
-
-  // 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(eviction_tiles_now_.begin(), eviction_tiles_now_.end(), sort_order);
-  std::sort(eviction_tiles_now_and_required_for_activation_.begin(),
-            eviction_tiles_now_and_required_for_activation_.end(),
-            sort_order);
-  std::sort(
-      eviction_tiles_soon_.begin(), eviction_tiles_soon_.end(), sort_order);
-  std::sort(eviction_tiles_soon_and_required_for_activation_.begin(),
-            eviction_tiles_soon_and_required_for_activation_.end(),
-            sort_order);
-  std::sort(eviction_tiles_eventually_.begin(),
-            eviction_tiles_eventually_.end(),
-            sort_order);
-  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);
-  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:
-      return &eviction_tiles_now_;
-    case NOW_AND_REQUIRED_FOR_ACTIVATION:
-      return &eviction_tiles_now_and_required_for_activation_;
-  }
-  NOTREACHED();
-  return &eviction_tiles_eventually_;
-}
-
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator()
     : tiling_(NULL), current_tile_(NULL) {}
 
@@ -1216,48 +1094,199 @@ operator++() {
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator()
-    : eviction_tiles_(NULL), current_eviction_tiles_index_(0u) {
+    : tiling_(nullptr),
+      eviction_category_(EVENTUALLY),
+      processing_occluded_now_tiles_(false),
+      processing_soon_border_rect_(false),
+      current_tile_(nullptr) {
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
     PictureLayerTiling* tiling,
-    TreePriority tree_priority,
     EvictionCategory category)
-    : eviction_tiles_(tiling->GetEvictionTiles(tree_priority, category)),
-      // 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);
+    : tiling_(tiling),
+      eviction_category_(category),
+      processing_occluded_now_tiles_(true),
+      processing_soon_border_rect_(true),
+      current_tile_(nullptr) {
+  switch (category) {

[reveman, 2014/11/18 20:56:21]

We already have a category switch statement at a different level, in
PictureLayerImpl::LayerEvictionTileIterator::AdvanceToNextCategory. This makes
me suspicious. It's not a performance concern. My intuition just tells me that
we're doing something wrong if we need this. It looks like we're forcing
ourselves to use some existing concept (TilingEvictionTileIterator and
categories) when it doesn't map to what's really going on.

This problem existed before this patch too but it was harder to tell as all we
did was pick a vector based on it.

+    case EVENTUALLY:
+      if (tiling_->has_eventually_rect_tiles_) {
+        spiral_iterator_ = TilingData::ReverseSpiralDifferenceIterator(
+            &tiling_->tiling_data_, tiling_->current_eventually_rect_,
+            tiling_->current_skewport_rect_,
+            tiling_->current_soon_border_rect_);
+      }
+      AdvanceEventually(true);
+      break;
+    case SOON:
+      if (tiling_->has_soon_border_rect_tiles_) {
+        spiral_iterator_ = TilingData::ReverseSpiralDifferenceIterator(
+            &tiling_->tiling_data_, tiling_->current_soon_border_rect_,
+            tiling_->current_skewport_rect_, tiling_->current_visible_rect_);
+      }
+      AdvanceSoon(true);
+      break;
+    case NOW:
+    case NOW_AND_REQUIRED_FOR_ACTIVATION:
+      if (tiling_->has_visible_rect_tiles_) {
+        visible_iterator_ = TilingData::Iterator(&tiling_->tiling_data_,
+                                                 tiling_->current_visible_rect_,
+                                                 false /* include_borders */);
+      }
+      AdvanceNow(true);
+      break;
+  }
+}
+
+void PictureLayerTiling::TilingEvictionTileIterator::AdvanceEventually(
+    bool first_run) {
+  if (!first_run)
+    ++spiral_iterator_;
+
+  current_tile_ = nullptr;
+  while (spiral_iterator_) {
+    std::pair<int, int> next_index = spiral_iterator_.index();
+    Tile* tile = tiling_->TileAt(next_index.first, next_index.second);
+
+    // If a tile has resources, then it is a valid tile to return.
+    if (tile && tile->HasResources()) {
+      current_tile_ = tile;
+      break;
+    }
+    ++spiral_iterator_;
+  }
+
+  if (current_tile_)
+    tiling_->UpdateTileAndTwinPriority(current_tile_);
+}
+
+void PictureLayerTiling::TilingEvictionTileIterator::AdvanceSoon(
+    bool first_run) {
+  if (!first_run)
+    ++spiral_iterator_;
+
+  // For the soon rect, we process both the soon border rect and
+  // the skewport rect.
+  current_tile_ = nullptr;
+  while (spiral_iterator_) {

[USE eero AT chromium.org, 2014/11/20 15:03:57]

This is wrong.
If there are skewport tiles but no soon border rect tiles, the constructor does
not initialize the spiral iterator. Then in here, the while block won't be
executed and the spiral iterator won't be replaced with skewport iterator thus
skewport tiles won't be iterated at all.

+    std::pair<int, int> next_index = spiral_iterator_.index();
+    Tile* tile = tiling_->TileAt(next_index.first, next_index.second);
+
+    // If the tile has resources, we can return it.
+    if (tile && tile->HasResources()) {
+      current_tile_ = tile;
+      break;
+    }
+    ++spiral_iterator_;
+
+    // If we ran out of tiles, but we were processing the soon border rect, then
+    // rebuild the iterator to iterate over skewport.

[reveman, 2014/11/18 20:56:21]

Why is Skewport not a different category? Wouldn't that make advancing
Eventually, Soon and Skewport the same and remove this special case?

+    if (!spiral_iterator_ && processing_soon_border_rect_) {
+      if (tiling_->has_skewport_rect_tiles_) {
+        spiral_iterator_ = TilingData::ReverseSpiralDifferenceIterator(
+            &tiling_->tiling_data_, tiling_->current_skewport_rect_,
+            tiling_->current_visible_rect_, tiling_->current_visible_rect_);
+      }
+      processing_soon_border_rect_ = false;
+    }
+  }
+
+  if (current_tile_)
+    tiling_->UpdateTileAndTwinPriority(current_tile_);
+}
+
+void PictureLayerTiling::TilingEvictionTileIterator::AdvanceNow(

[reveman, 2014/11/18 20:56:21]

Could we either generalize the Now category code so it's the same as other
categories (just operating on a different data set). Or handle the difference in
LayerEvictionTileIterator instead of hiding it in here? ie. making the layer
iterator first iterate "prepaint" then "visible",
LayerEvictionTileIterator::current_iterator_ ->
LayerEvictionTileIterator::current_prepaint_iterator_/current_visible_iterator_.

+    bool first_run) {
+  if (!first_run)
+    ++visible_iterator_;
+
+  // For NOW bin, we process the visible rect, returning occluded tiles first,
+  // followed by unoccluded tiles.
+  current_tile_ = nullptr;
+  while (visible_iterator_ || processing_occluded_now_tiles_) {
+    if (!visible_iterator_) {
+      processing_occluded_now_tiles_ = false;
+      if (tiling_->has_visible_rect_tiles_) {
+        visible_iterator_ = TilingData::Iterator(&tiling_->tiling_data_,
+                                                 tiling_->current_visible_rect_,
+                                                 false /* include_borders */);
+      }
+      continue;
+    }
+
+    std::pair<int, int> next_index = visible_iterator_.index();
+    Tile* tile = tiling_->TileAt(next_index.first, next_index.second);
+
+    // If the tile doesn't have resources, then we won't return it.
+    if (!tile || !tile->HasResources()) {
+      ++visible_iterator_;
+      continue;
+    }
+
+    bool tile_required_for_activation = false;
+    if (tiling_->client_->GetTree() == PENDING_TREE) {
+      tile_required_for_activation =
+          tiling_->IsTileRequiredForActivationIfVisible(tile);
+    }
+
+    // Skip the tile if it doesn't match the requested activation criteria.
+    if ((eviction_category_ == NOW_AND_REQUIRED_FOR_ACTIVATION &&
+         !tile_required_for_activation) ||
+        (eviction_category_ == NOW && tile_required_for_activation)) {
+      ++visible_iterator_;
+      continue;
+    }
+
+    // If the tile is occlusion doesn't match the phase we're processing now,
+    // skip it, since it was either already processed or will be processed
+    // later.
+    if (tiling_->IsTileOccluded(tile) != processing_occluded_now_tiles_) {
+      ++visible_iterator_;
+      continue;
+    }
+
+    // All of the above checks passed, so the tile is good to return now.
+    current_tile_ = tile;
+    break;
+  }
+
+  if (current_tile_)
+    tiling_->UpdateTileAndTwinPriority(current_tile_);
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::~TilingEvictionTileIterator() {
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::operator bool() const {
-  return eviction_tiles_ &&
-         current_eviction_tiles_index_ != eviction_tiles_->size();
+  return !!current_tile_;
 }
 
 Tile* PictureLayerTiling::TilingEvictionTileIterator::operator*() {
   DCHECK(*this);
-  return (*eviction_tiles_)[current_eviction_tiles_index_];
+  return current_tile_;
 }
 
 const Tile* PictureLayerTiling::TilingEvictionTileIterator::operator*() const {
   DCHECK(*this);
-  return (*eviction_tiles_)[current_eviction_tiles_index_];
+  return current_tile_;
 }
 
 PictureLayerTiling::TilingEvictionTileIterator&
 PictureLayerTiling::TilingEvictionTileIterator::
 operator++() {
-  DCHECK(*this);
-  do {
-    ++current_eviction_tiles_index_;
-  } while (current_eviction_tiles_index_ != eviction_tiles_->size() &&
-           !(*eviction_tiles_)[current_eviction_tiles_index_]->HasResources());
-
+  switch (eviction_category_) {
+    case EVENTUALLY:
+      AdvanceEventually(false);
+      break;
+    case SOON:
+      AdvanceSoon(false);
+      break;
+    case NOW:
+    case NOW_AND_REQUIRED_FOR_ACTIVATION:
+      AdvanceNow(false);
+      break;
+  }
   return *this;
 }