cc: Move raster_source from Tile to PrioritizedTile

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 <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 239 matching lines @@
     layer->draw_properties().page_scale_factor = page_scale_factor;
     layer->draw_properties().maximum_animation_contents_scale =
         maximum_animation_contents_scale;
     layer->draw_properties().starting_animation_contents_scale =
         starting_animation_contents_scale;
     layer->draw_properties().screen_space_transform_is_animating =
         animating_transform_to_screen;
     bool resourceless_software_draw = false;
     layer->UpdateTiles(resourceless_software_draw);
   }
-  static void VerifyAllTilesExistAndHavePile(
+  static void VerifyAllPrioritizedTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
+    auto prioritized_tiles =
+        tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
-      EXPECT_EQ(pile, iter->raster_source());
+      EXPECT_EQ(pile, prioritized_tiles[*iter].raster_source());
     }
   }
 
   void SetContentsScaleOnBothLayers(float contents_scale,
                                     float device_scale_factor,
                                     float page_scale_factor,
                                     float maximum_animation_contents_scale,
                                     float starting_animation_contents_scale,
                                     bool animating_transform) {
     SetupDrawPropertiesAndUpdateTiles(
@@ skipping 408 matching lines @@
   EXPECT_EQ(2u, pending_layer_->num_tilings());
   EXPECT_EQ(3u, active_layer_->num_tilings());
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect content_invalidation = gfx::ScaleToEnclosingRect(
         layer_invalidation,
         tiling->contents_scale());
+    auto prioritized_tiles =
+        tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       // We don't always have a tile, but when we do it's because it was
       // invalidated and it has the latest raster source.
       if (*iter) {
         EXPECT_FALSE(iter.geometry_rect().IsEmpty());
-        EXPECT_EQ(pending_pile.get(), iter->raster_source());
+        EXPECT_EQ(pending_pile.get(), prioritized_tiles[*iter].raster_source());
         EXPECT_TRUE(iter.geometry_rect().Intersects(content_invalidation));
       } else {
         // We don't create tiles in non-invalidated regions.
         EXPECT_FALSE(iter.geometry_rect().Intersects(content_invalidation));
       }
     }
   }
 
   tilings = active_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect content_invalidation =
         gfx::ScaleToEnclosingRect(layer_invalidation, tiling->contents_scale());
+    auto prioritized_tiles =
+        tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       // Pile will be updated upon activation.
-      EXPECT_EQ(active_pile.get(), iter->raster_source());
+      EXPECT_EQ(active_pile.get(), prioritized_tiles[*iter].raster_source());
     }
   }
 }
 
 TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
   gfx::Size tile_size(90, 80);
   gfx::Size layer_bounds(300, 500);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTreesWithInvalidation(pending_pile, active_pile,
                              gfx::Rect(layer_bounds));
 
   EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
             active_layer_->tilings()->num_tilings());
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i)
-    VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get());
+    VerifyAllPrioritizedTilesExistAndHavePile(tilings->tiling_at(i),
+                                              pending_pile.get());
 }
 
 TEST_F(PictureLayerImplTest, UpdateTilesCreatesTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ skipping 4217 matching lines @@
   host_impl_.SetDeviceScaleFactor(1.f);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
 
   EXPECT_TRUE(pending_layer_->RasterSourceUsesLCDText());
   EXPECT_TRUE(pending_layer_->HighResTiling()->has_tiles());
   std::vector<Tile*> tiles =
       pending_layer_->HighResTiling()->AllTilesForTesting();
+  auto prioritized_tiles = pending_layer_->HighResTiling()
+                               ->UpdateAndGetAllPrioritizedTilesForTesting();
+
   for (Tile* tile : tiles)
-    EXPECT_EQ(pending_layer_->raster_source(), tile->raster_source());
+    EXPECT_EQ(pending_layer_->raster_source(),
+              prioritized_tiles[tile].raster_source());
 
   pending_layer_->draw_properties().can_use_lcd_text = false;
   pending_layer_->UpdateCanUseLCDTextAfterCommit();
 
   EXPECT_FALSE(pending_layer_->RasterSourceUsesLCDText());
   EXPECT_NE(pending_pile.get(), pending_layer_->raster_source());
   EXPECT_TRUE(pending_layer_->HighResTiling()->has_tiles());
   tiles = pending_layer_->HighResTiling()->AllTilesForTesting();
+  prioritized_tiles = pending_layer_->HighResTiling()
+                          ->UpdateAndGetAllPrioritizedTilesForTesting();
   for (Tile* tile : tiles)
-    EXPECT_EQ(pending_layer_->raster_source(), tile->raster_source());
+    EXPECT_EQ(pending_layer_->raster_source(),
+              prioritized_tiles[tile].raster_source());
 }
 
 class TileSizeSettings : public GpuRasterizationEnabledSettings {
  public:
   TileSizeSettings() {
     default_tile_size = gfx::Size(100, 100);
     max_untiled_layer_size = gfx::Size(200, 200);
   }
 };
 
@@ skipping 58 matching lines @@
   result = layer->CalculateTileSize(gfx::Size(447, 400));
   EXPECT_EQ(result.width(), 448);
   EXPECT_EQ(result.height(), 448);
   result = layer->CalculateTileSize(gfx::Size(500, 499));
   EXPECT_EQ(result.width(), 512);
   EXPECT_EQ(result.height(), 500 + 2);
 }
 
 }  // namespace
 }  // namespace cc