cc: Use reverse spiral iterator in tiling eviction.

cc/layers/picture_layer_impl_unittest.cc

Index: cc/layers/picture_layer_impl_unittest.cc
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index a75feb0c0bdeac8e72bcf16f55ff782156e2fd9b..bdfa21506a06e6fef91d34902de611d02de705da 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -2951,8 +2951,7 @@ TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) {
   EXPECT_FALSE(it);
 
   // Tiles don't have resources yet.
-  it = PictureLayerImpl::LayerEvictionTileIterator(
-      pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES);
+  it = PictureLayerImpl::LayerEvictionTileIterator(pending_layer_);
   EXPECT_FALSE(it);
 
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
@@ -2962,9 +2961,9 @@ TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) {
   size_t scale_index = 0;
   bool reached_visible = false;
   Tile* last_tile = nullptr;
-  for (it = PictureLayerImpl::LayerEvictionTileIterator(
-           pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES);
-       it;
+  int distance_decreasing = 0;
+  int distance_increasing = 0;
+  for (it = PictureLayerImpl::LayerEvictionTileIterator(pending_layer_); it;
        ++it) {
     Tile* tile = *it;
     if (!last_tile)
@@ -2991,21 +2990,26 @@ TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) {
     EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]);
     unique_tiles.insert(tile);
 
-    // If the tile is the same rough bin as last tile (same activation, bin, and
-    // scale), then distance should be decreasing.
     if (tile->required_for_activation() ==
             last_tile->required_for_activation() &&
         priority.priority_bin ==
             last_tile->priority(PENDING_TREE).priority_bin &&
         std::abs(tile->contents_scale() - last_tile->contents_scale()) <
             std::numeric_limits<float>::epsilon()) {
-      EXPECT_LE(priority.distance_to_visible,
-                last_tile->priority(PENDING_TREE).distance_to_visible);
+      if (priority.distance_to_visible <=
+          last_tile->priority(PENDING_TREE).distance_to_visible) {
+        ++distance_decreasing;
+      } else {
+        ++distance_increasing;
+      }
     }
 
     last_tile = tile;
   }
 
+  EXPECT_EQ(7, distance_increasing);
+  EXPECT_EQ(55, distance_decreasing);
+
   EXPECT_TRUE(reached_visible);
   EXPECT_EQ(65u, unique_tiles.size());
 
@@ -3814,52 +3818,41 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
   OcclusionTrackingPictureLayerImplTest()
       : PictureLayerImplTest(OcclusionTrackingSettings()) {}
 
-  void VerifyEvictionConsidersOcclusion(
-      PictureLayerImpl* layer,
-      size_t expected_occluded_tile_count[NUM_TREE_PRIORITIES]) {
-    for (int priority_count = 0; priority_count < NUM_TREE_PRIORITIES;
-         ++priority_count) {
-      TreePriority tree_priority = static_cast<TreePriority>(priority_count);
-      size_t occluded_tile_count = 0u;
-      Tile* last_tile = nullptr;
-
-      for (PictureLayerImpl::LayerEvictionTileIterator it =
-               PictureLayerImpl::LayerEvictionTileIterator(layer,
-                                                           tree_priority);
-           it;
-           ++it) {
-        Tile* tile = *it;
-        if (!last_tile)
-          last_tile = tile;
-
-        // The only way we will encounter an occluded tile after an unoccluded
-        // tile is if the priorty bin decreased, the tile is required for
-        // activation, or the scale changed.
-        bool tile_is_occluded =
-            tile->is_occluded_for_tree_priority(tree_priority);
-        if (tile_is_occluded) {
-          occluded_tile_count++;
-
-          bool last_tile_is_occluded =
-              last_tile->is_occluded_for_tree_priority(tree_priority);
-          if (!last_tile_is_occluded) {
-            TilePriority::PriorityBin tile_priority_bin =
-                tile->priority_for_tree_priority(tree_priority).priority_bin;
-            TilePriority::PriorityBin last_tile_priority_bin =
-                last_tile->priority_for_tree_priority(tree_priority)
-                    .priority_bin;
-
-            EXPECT_TRUE(
-                (tile_priority_bin < last_tile_priority_bin) ||
-                tile->required_for_activation() ||
-                (tile->contents_scale() != last_tile->contents_scale()));
-          }
-        }
+  void VerifyEvictionConsidersOcclusion(PictureLayerImpl* layer,
+                                        WhichTree tree,
+                                        size_t expected_occluded_tile_count) {
+    size_t occluded_tile_count = 0u;
+    Tile* last_tile = nullptr;
+
+    for (PictureLayerImpl::LayerEvictionTileIterator it =
+             PictureLayerImpl::LayerEvictionTileIterator(layer);
+         it; ++it) {
+      Tile* tile = *it;
+      if (!last_tile)
         last_tile = tile;
+
+      // The only way we will encounter an occluded tile after an unoccluded
+      // tile is if the priorty bin decreased, the tile is required for
+      // activation, or the scale changed.
+      bool tile_is_occluded = tile->is_occluded(tree);
+      if (tile_is_occluded) {
+        occluded_tile_count++;
+
+        bool last_tile_is_occluded = last_tile->is_occluded(tree);
+        if (!last_tile_is_occluded) {
+          TilePriority::PriorityBin tile_priority_bin =
+              tile->priority(tree).priority_bin;
+          TilePriority::PriorityBin last_tile_priority_bin =
+              last_tile->priority(tree).priority_bin;
+
+          EXPECT_TRUE((tile_priority_bin < last_tile_priority_bin) ||
+                      tile->required_for_activation() ||
+                      (tile->contents_scale() != last_tile->contents_scale()));
+        }
       }
-      EXPECT_EQ(expected_occluded_tile_count[priority_count],
-                occluded_tile_count);
+      last_tile = tile;
     }
+    EXPECT_EQ(expected_occluded_tile_count, occluded_tile_count);
   }
 };
 
@@ -4332,11 +4325,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
   size_t expected_occluded_tile_count_on_active[] = {30u, 5u, 4u, 2u, 2u};
   size_t expected_occluded_tile_count_on_pending[] = {30u, 5u, 4u, 2u, 2u};
 
-  // The total expected number of occluded tiles on all tilings for each of the
-  // 3 tree priorities.
-  size_t total_expected_occluded_tile_count[] = {13u, 43u, 43u};
-
-  ASSERT_EQ(arraysize(total_expected_occluded_tile_count), NUM_TREE_PRIORITIES);
+  size_t total_expected_occluded_count_on_trees[] = {43u, 43u};
 
   // Verify number of occluded tiles on the pending layer for each tiling.
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
@@ -4419,10 +4408,12 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
 
-  VerifyEvictionConsidersOcclusion(pending_layer_,
-                                   total_expected_occluded_tile_count);
-  VerifyEvictionConsidersOcclusion(active_layer_,
-                                   total_expected_occluded_tile_count);
+  VerifyEvictionConsidersOcclusion(
+      pending_layer_, PENDING_TREE,
+      total_expected_occluded_count_on_trees[PENDING_TREE]);
+  VerifyEvictionConsidersOcclusion(
+      active_layer_, ACTIVE_TREE,
+      total_expected_occluded_count_on_trees[ACTIVE_TREE]);
 }
 
 TEST_F(PictureLayerImplTest, PendingOrActiveTwinLayer) {