cc: Keep tile eviction prioritization consistent with raster priorities.

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 2943 matching lines @@
     }
   }
 
   // Sanity checks.
   EXPECT_EQ(16u, all_tiles.size());
   EXPECT_EQ(16u, all_tiles_set.size());
   EXPECT_GT(number_of_marked_tiles, 1u);
   EXPECT_GT(number_of_unmarked_tiles, 1u);
 
   // Tiles don't have resources yet.
-  std::unique_ptr<TilingSetEvictionQueue> queue(
-      new TilingSetEvictionQueue(pending_layer()->picture_layer_tiling_set()));
+  std::unique_ptr<TilingSetEvictionQueue> queue(new TilingSetEvictionQueue(
+      pending_layer()->picture_layer_tiling_set(),
+      pending_layer()->contributes_to_drawn_render_surface()));
   EXPECT_TRUE(queue->IsEmpty());
 
   host_impl()->tile_manager()->InitializeTilesWithResourcesForTesting(
       all_tiles);
 
   std::set<Tile*> unique_tiles;
   float expected_scales[] = {low_res_factor, 1.f};
   size_t scale_index = 0;
   bool reached_visible = false;
   PrioritizedTile last_tile;
   size_t distance_decreasing = 0;
   size_t distance_increasing = 0;
-  queue.reset(
-      new TilingSetEvictionQueue(pending_layer()->picture_layer_tiling_set()));
+  queue.reset(new TilingSetEvictionQueue(
+      pending_layer()->picture_layer_tiling_set(),
+      pending_layer()->contributes_to_drawn_render_surface()));
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     Tile* tile = prioritized_tile.tile();
     if (!last_tile.tile())
       last_tile = prioritized_tile;
 
     EXPECT_TRUE(tile);
 
     TilePriority priority = prioritized_tile.priority();
 
@@ skipping 663 matching lines @@
     return settings;
   }
 
   void VerifyEvictionConsidersOcclusion(FakePictureLayerImpl* layer,
                                         WhichTree tree,
                                         size_t expected_occluded_tile_count,
                                         int source_line) {
     size_t occluded_tile_count = 0u;
     PrioritizedTile last_tile;
 
-    std::unique_ptr<TilingSetEvictionQueue> queue(
-        new TilingSetEvictionQueue(layer->picture_layer_tiling_set()));
+    std::unique_ptr<TilingSetEvictionQueue> queue(new TilingSetEvictionQueue(
+        layer->picture_layer_tiling_set(),
+        layer->contributes_to_drawn_render_surface()));
     while (!queue->IsEmpty()) {
       PrioritizedTile prioritized_tile = queue->Top();
       Tile* tile = prioritized_tile.tile();
       if (!last_tile.tile())
         last_tile = prioritized_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 = prioritized_tile.is_occluded();
@@ skipping 1469 matching lines @@
     EXPECT_EQ(gfx::AxisTransform2d(2.25f, gfx::Vector2dF(0.75f, 0.25f)),
               tiling->raster_transform());
     EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
     for (auto* tile : tiling->AllTilesForTesting())
       EXPECT_EQ(tile->raster_transform(), tiling->raster_transform());
   }
 }
 
 }  // namespace
 }  // namespace cc