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 9716aa91030bf3cf3bfb5094b7c9b7808c9703cc..3de7bb2799512e16b83877e7098ce65d58048508 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -2816,6 +2816,8 @@ TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) {
   size_t scale_index = 0;
   bool reached_visible = false;
   Tile* last_tile = nullptr;
+  int distance_decreasing = 0;
+  int distance_increasing = 0;
   for (it = PictureLayerImpl::LayerEvictionTileIterator(
            pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES);
        it;
@@ -2845,21 +2847,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);

[ajuma, 2014/10/23 23:12:54]

Is there an intuitive explanation for why we get these numbers?

[vmpstr, 2014/10/29 18:19:41]

Well.. I'm not sure how intuitive it is, starting with eventually rect we'll
spiral down, but going from side to corner the distance will increase and going
from corner to side the distance will decrease, so it isn't technically distance
decreasing order. This check is just so that we're _mostly_ distance decreasing.
In raster iterators, I have something like distance_decreasing > 3 * total_tiles
/ 4, but I figured might as well put in the actual numbers.

If you have a suggestion for a better solution, I'll be happy to put it in (I'm
not exactly proud of this test :) )

[ajuma, 2014/10/29 19:42:39]

Ok, I mostly wanted to find out if these specific values were intended to be
immediately obvious from reading the test, since if they were, I was clearly
missing something :)  It makes sense that we're checking that we're mostly
distance decreasing. I'd suggest adding a comment about this.

+
   EXPECT_TRUE(reached_visible);
   EXPECT_EQ(65u, unique_tiles.size());
 
@@ -3667,9 +3674,9 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
   OcclusionTrackingPictureLayerImplTest()
       : PictureLayerImplTest(OcclusionTrackingSettings()) {}
 
-  void VerifyEvictionConsidersOcclusion(
-      PictureLayerImpl* layer,
-      size_t expected_occluded_tile_count[NUM_TREE_PRIORITIES]) {
+  void VerifyEvictionConsidersOcclusion(PictureLayerImpl* layer,
+                                        WhichTree tree,
+                                        size_t expected_occluded_tile_count) {
     for (int priority_count = 0; priority_count < NUM_TREE_PRIORITIES;
          ++priority_count) {
       TreePriority tree_priority = static_cast<TreePriority>(priority_count);
@@ -3688,19 +3695,16 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
         // 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);
+        bool tile_is_occluded = tile->is_occluded(tree);
         if (tile_is_occluded) {
           occluded_tile_count++;
 
-          bool last_tile_is_occluded =
-              last_tile->is_occluded_for_tree_priority(tree_priority);
+          bool last_tile_is_occluded = last_tile->is_occluded(tree);
           if (!last_tile_is_occluded) {
             TilePriority::PriorityBin tile_priority_bin =
-                tile->priority_for_tree_priority(tree_priority).priority_bin;
+                tile->priority(tree).priority_bin;
             TilePriority::PriorityBin last_tile_priority_bin =
-                last_tile->priority_for_tree_priority(tree_priority)
-                    .priority_bin;
+                last_tile->priority(tree).priority_bin;
 
             EXPECT_TRUE(
                 (tile_priority_bin < last_tile_priority_bin) ||
@@ -3710,8 +3714,7 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
         }
         last_tile = tile;
       }
-      EXPECT_EQ(expected_occluded_tile_count[priority_count],
-                occluded_tile_count);
+      EXPECT_EQ(expected_occluded_tile_count, occluded_tile_count);
     }
   }
 };
@@ -4185,11 +4188,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) {
@@ -4272,10 +4271,14 @@ 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, RecycledTwinLayer) {