cc: Use reverse spiral iterator in tiling eviction.

cc/resources/picture_layer_tiling_unittest.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 <limits>
 #include <set>
 
 #include "cc/base/math_util.h"
@@ skipping 47 matching lines @@
       float contents_scale,
       const gfx::Size& layer_bounds,
       PictureLayerTilingClient* client) {
     return make_scoped_ptr(new TestablePictureLayerTiling(
         contents_scale,
         layer_bounds,
         client));
   }
 
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
-  bool eviction_tiles_cache_valid() const {
-    return eviction_tiles_cache_valid_;
-  }
 
   using PictureLayerTiling::ComputeSkewport;
   using PictureLayerTiling::RemoveTileAt;
 
  protected:
   TestablePictureLayerTiling(float contents_scale,
                              const gfx::Size& layer_bounds,
                              PictureLayerTilingClient* client)
       : PictureLayerTiling(contents_scale, layer_bounds, client) { }
 };
@@ skipping 1197 matching lines @@
   tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
   tiling->ComputeTilePriorityRects(
       ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   PictureLayerTiling::TilingRasterTileIterator empty_iterator;
   EXPECT_FALSE(empty_iterator);
 
   std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
 
-  PictureLayerTiling::TilingEvictionTileIterator it(
-      tiling.get(), SMOOTHNESS_TAKES_PRIORITY, PictureLayerTiling::NOW);
+  PictureLayerTiling::TilingEvictionTileIterator it(tiling.get(),
+                                                    PictureLayerTiling::NOW);
 
   // Tiles don't have resources to evict.
   EXPECT_FALSE(it);
 
   // Sanity check.
   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, PictureLayerTiling::EVENTUALLY);
+      tiling.get(), PictureLayerTiling::EVENTUALLY);
   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);
   }
 
-  it = PictureLayerTiling::TilingEvictionTileIterator(
-      tiling.get(), SMOOTHNESS_TAKES_PRIORITY, PictureLayerTiling::SOON);
+  it = PictureLayerTiling::TilingEvictionTileIterator(tiling.get(),
+                                                      PictureLayerTiling::SOON);
   EXPECT_TRUE(it);
   for (; it; ++it) {
     Tile* tile = *it;
     EXPECT_TRUE(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, PictureLayerTiling::NOW);
+  it = PictureLayerTiling::TilingEvictionTileIterator(tiling.get(),
+                                                      PictureLayerTiling::NOW);
   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,
       PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION);
   EXPECT_FALSE(it);
 
   EXPECT_GT(all_tiles_set.size(), 0u);
   EXPECT_EQ(all_tiles_set, eviction_tiles);
-
-  EXPECT_TRUE(tiling->eviction_tiles_cache_valid());
-  tiling->RemoveTileAt(0, 0, nullptr);
-  EXPECT_FALSE(tiling->eviction_tiles_cache_valid());
-
-  it = PictureLayerTiling::TilingEvictionTileIterator(
-      tiling.get(), SMOOTHNESS_TAKES_PRIORITY,
-      PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION);
-  EXPECT_TRUE(tiling->eviction_tiles_cache_valid());
-  tiling->Reset();
-  EXPECT_FALSE(tiling->eviction_tiles_cache_valid());
 }
 
 TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
   gfx::Size layer_bounds(1099, 801);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   client_.set_tree(ACTIVE_TREE);
   tiling_->ComputeTilePriorityRects(
@@ skipping 807 matching lines @@
   EXPECT_EQ(active_tiling->TileAt(0, 0), recycle_tiling->TileAt(0, 0));
 
   // Reset the active tiling. The recycle tiles should be released too.
   active_tiling->Reset();
   EXPECT_FALSE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 }
 
 }  // namespace
 }  // namespace cc