cc: Remove PicturePile and PicturePileImpl.

cc/tiles/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 <limits>
 #include <set>
 
 #include "cc/base/math_util.h"
+#include "cc/test/fake_display_list_raster_source.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
-#include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/tiles/picture_layer_tiling.h"
 #include "cc/tiles/picture_layer_tiling_set.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
@@ skipping 55 matching lines @@
 
 class PictureLayerTilingIteratorTest : public testing::Test {
  public:
   PictureLayerTilingIteratorTest() {}
   ~PictureLayerTilingIteratorTest() override {}
 
   void Initialize(const gfx::Size& tile_size,
                   float contents_scale,
                   const gfx::Size& layer_bounds) {
     client_.SetTileSize(tile_size);
-    scoped_refptr<FakePicturePileImpl> pile =
-        FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
-    tiling_ = TestablePictureLayerTiling::Create(
-        PENDING_TREE, contents_scale, pile, &client_, LayerTreeSettings());
+    scoped_refptr<FakeDisplayListRasterSource> raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+    tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, contents_scale,
+                                                 raster_source, &client_,
+                                                 LayerTreeSettings());
     tiling_->set_resolution(HIGH_RESOLUTION);
   }
 
   void InitializeActive(const gfx::Size& tile_size,
                         float contents_scale,
                         const gfx::Size& layer_bounds) {
     client_.SetTileSize(tile_size);
-    scoped_refptr<FakePicturePileImpl> pile =
-        FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
-    tiling_ = TestablePictureLayerTiling::Create(
-        ACTIVE_TREE, contents_scale, pile, &client_, LayerTreeSettings());
+    scoped_refptr<FakeDisplayListRasterSource> raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+    tiling_ = TestablePictureLayerTiling::Create(ACTIVE_TREE, contents_scale,
+                                                 raster_source, &client_,
+                                                 LayerTreeSettings());
     tiling_->set_resolution(HIGH_RESOLUTION);
   }
 
   void SetLiveRectAndVerifyTiles(const gfx::Rect& live_tiles_rect) {
     tiling_->SetLiveTilesRect(live_tiles_rect);
 
     std::vector<Tile*> tiles = tiling_->AllTilesForTesting();
     for (std::vector<Tile*>::iterator iter = tiles.begin();
          iter != tiles.end();
          ++iter) {
@@ skipping 91 matching lines @@
   gfx::Size tile_size(100, 100);
   gfx::Size original_layer_size(10, 10);
   InitializeActive(tile_size, 1.f, original_layer_size);
   SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size));
 
   // Tiling only has one tile, since its total size is less than one.
   EXPECT_TRUE(tiling_->TileAt(0, 0));
 
   // Stop creating tiles so that any invalidations are left as holes.
   gfx::Size new_layer_size(200, 200);
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(new_layer_size);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreatePartiallyFilled(new_layer_size,
+                                                         gfx::Rect());
 
   Region invalidation =
       SubtractRegions(gfx::Rect(tile_size), gfx::Rect(original_layer_size));
-  tiling_->SetRasterSourceAndResize(pile);
+  tiling_->SetRasterSourceAndResize(raster_source);
   EXPECT_TRUE(tiling_->TileAt(0, 0));
   tiling_->Invalidate(invalidation);
   EXPECT_FALSE(tiling_->TileAt(0, 0));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, CreateMissingTilesStaysInsideLiveRect) {
   // The tiling has three rows and columns.
   Initialize(gfx::Size(100, 100), 1.f, gfx::Size(250, 250));
   EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_x());
   EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_y());
@@ skipping 35 matching lines @@
   EXPECT_TRUE(tiling_->TileAt(2, 2));
   EXPECT_TRUE(tiling_->TileAt(2, 3));
   EXPECT_TRUE(tiling_->TileAt(1, 3));
   EXPECT_TRUE(tiling_->TileAt(0, 3));
 
   int right = tiling_->TilingDataForTesting().TileBounds(2, 2).x();
   int bottom = tiling_->TilingDataForTesting().TileBounds(2, 3).y();
 
   // Shrink the tiling so that the last tile row/column is entirely in the
   // border pixels of the interior tiles. That row/column is removed.
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(
           gfx::Size(right + 1, bottom + 1));
-  tiling_->SetRasterSourceAndResize(pile);
+  tiling_->SetRasterSourceAndResize(raster_source);
   EXPECT_EQ(2, tiling_->TilingDataForTesting().num_tiles_x());
   EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_y());
 
-  // The live tiles rect was clamped to the pile size.
+  // The live tiles rect was clamped to the raster source size.
   EXPECT_EQ(gfx::Rect(right + 1, bottom + 1), tiling_->live_tiles_rect());
 
   // Since the row/column is gone, the tiles should be gone too.
   EXPECT_FALSE(tiling_->TileAt(2, 0));
   EXPECT_FALSE(tiling_->TileAt(2, 1));
   EXPECT_FALSE(tiling_->TileAt(2, 2));
   EXPECT_FALSE(tiling_->TileAt(2, 3));
   EXPECT_FALSE(tiling_->TileAt(1, 3));
   EXPECT_FALSE(tiling_->TileAt(0, 3));
 
   // Growing outside the current right/bottom tiles border pixels should create
   // the tiles again, even though the live rect has not changed size.
-  pile = FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+  raster_source = FakeDisplayListRasterSource::CreateFilled(
       gfx::Size(right + 2, bottom + 2));
-  tiling_->SetRasterSourceAndResize(pile);
+  tiling_->SetRasterSourceAndResize(raster_source);
   EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_x());
   EXPECT_EQ(4, tiling_->TilingDataForTesting().num_tiles_y());
 
   // Not changed.
   EXPECT_EQ(gfx::Rect(right + 1, bottom + 1), tiling_->live_tiles_rect());
 
   // The last row/column tiles are inside the live tiles rect.
   EXPECT_TRUE(gfx::Rect(right + 1, bottom + 1).Intersects(
       tiling_->TilingDataForTesting().TileBounds(2, 0)));
   EXPECT_TRUE(gfx::Rect(right + 1, bottom + 1).Intersects(
@@ skipping 111 matching lines @@
   // deletes tiles that intersect that invalidation.
   gfx::Size tile_size(100, 100);
   gfx::Size original_layer_size(99, 99);
   InitializeActive(tile_size, 1.f, original_layer_size);
   SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size));
 
   // Tiling only has one tile, since its total size is less than one.
   EXPECT_TRUE(tiling_->TileAt(0, 0));
 
   // Stop creating tiles so that any invalidations are left as holes.
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(
-          gfx::Size(200, 200));
-  tiling_->SetRasterSourceAndResize(pile);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreatePartiallyFilled(gfx::Size(200, 200),
+                                                         gfx::Rect());
+  tiling_->SetRasterSourceAndResize(raster_source);
 
   Region invalidation =
       SubtractRegions(gfx::Rect(tile_size), gfx::Rect(original_layer_size));
   EXPECT_TRUE(tiling_->TileAt(0, 0));
   tiling_->Invalidate(invalidation);
   EXPECT_FALSE(tiling_->TileAt(0, 0));
 
   // The original tile was the same size after resize, but it would include new
   // border pixels.
   EXPECT_EQ(gfx::Rect(original_layer_size),
@@ skipping 104 matching lines @@
 TEST(PictureLayerTilingTest, SkewportLimits) {
   FakePictureLayerTilingClient client;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
   settings.skewport_extrapolation_limit_in_content_pixels = 75;
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         settings);
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, settings);
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect down_skewport =
       tiling->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
 
   EXPECT_EQ(0, down_skewport.x());
   EXPECT_EQ(50, down_skewport.y());
   EXPECT_EQ(100, down_skewport.width());
@@ skipping 59 matching lines @@
   EXPECT_EQ(175, move_skewport_far.height());
   EXPECT_TRUE(move_skewport_far.Contains(gfx::Rect(0, 5000, 100, 100)));
 }
 
 TEST(PictureLayerTilingTest, ComputeSkewportExtremeCases) {
   FakePictureLayerTilingClient client;
 
   gfx::Size layer_bounds(200, 200);
   client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         settings);
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, settings);
 
   gfx::Rect viewport1(-1918, 255860, 4010, 2356);
   gfx::Rect viewport2(-7088, -91738, 14212, 8350);
   gfx::Rect viewport3(-12730024, -158883296, 24607540, 14454512);
   double time = 1.0;
   tiling->ComputeTilePriorityRects(viewport1, 1.f, time, Occlusion());
   time += 0.016;
   EXPECT_TRUE(tiling->ComputeSkewport(time, viewport2).Contains(viewport2));
   tiling->ComputeTilePriorityRects(viewport2, 1.f, time, Occlusion());
   time += 0.016;
   EXPECT_TRUE(tiling->ComputeSkewport(time, viewport3).Contains(viewport3));
 }
 
 TEST(PictureLayerTilingTest, ComputeSkewport) {
   FakePictureLayerTilingClient client;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, LayerTreeSettings());
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect down_skewport =
       tiling->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
 
   EXPECT_EQ(0, down_skewport.x());
   EXPECT_EQ(50, down_skewport.y());
   EXPECT_EQ(100, down_skewport.width());
@@ skipping 37 matching lines @@
 }
 
 TEST(PictureLayerTilingTest, SkewportThroughUpdateTilePriorities) {
   FakePictureLayerTilingClient client;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, LayerTreeSettings());
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect viewport_50 = gfx::Rect(0, 50, 100, 100);
   gfx::Rect skewport_50 = tiling->ComputeSkewport(1.5, viewport_50);
 
   EXPECT_EQ(gfx::Rect(0, 50, 100, 200), skewport_50);
   tiling->ComputeTilePriorityRects(viewport_50, 1.f, 1.5, Occlusion());
 
@@ skipping 49 matching lines @@
   gfx::Size layer_bounds(1500, 1500);
 
   client.SetTileSize(gfx::Size(10, 10));
   LayerTreeSettings settings;
 
   // Tiling at 0.25 scale: this should create 47x47 tiles of size 10x10.
   // The reason is that each tile has a one pixel border, so tile at (1, 2)
   // for instance begins at (8, 16) pixels. So tile at (46, 46) will begin at
   // (368, 368) and extend to the end of 1500 * 0.25 = 375 edge of the
   // tiling.
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 0.25f, pile, &client,
-                                         settings);
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 0.25f, raster_source,
+                                         &client, settings);
   tiling->set_resolution(HIGH_RESOLUTION);
   gfx::Rect viewport_in_content_space =
       gfx::ScaleToEnclosedRect(viewport, 0.25f);
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   // Compute the soon border.
   float inset = PictureLayerTiling::CalculateSoonBorderDistance(
       viewport_in_content_space, 1.0f / 0.25f);
@@ skipping 136 matching lines @@
   priority = prioritized_tiles[tiling->TileAt(5, 1)].priority();
   EXPECT_FLOAT_EQ(136.f, priority.distance_to_visible);
 
   priority = prioritized_tiles[tiling->TileAt(2, 5)].priority();
   EXPECT_FLOAT_EQ(56.f, priority.distance_to_visible);
 
   priority = prioritized_tiles[tiling->TileAt(3, 4)].priority();
   EXPECT_FLOAT_EQ(8.f, priority.distance_to_visible);
 
   // Test additional scales.
-  tiling = TestablePictureLayerTiling::Create(ACTIVE_TREE, 0.2f, pile, &client,
-                                              LayerTreeSettings());
+  tiling = TestablePictureLayerTiling::Create(ACTIVE_TREE, 0.2f, raster_source,
+                                              &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
   tiling->ComputeTilePriorityRects(viewport, 1.0f, 4.0, Occlusion());
   prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   priority = prioritized_tiles[tiling->TileAt(5, 1)].priority();
   EXPECT_FLOAT_EQ(110.f, priority.distance_to_visible);
 
   priority = prioritized_tiles[tiling->TileAt(2, 5)].priority();
   EXPECT_FLOAT_EQ(70.f, priority.distance_to_visible);
 
@@ skipping 91 matching lines @@
       << "Current tile rect is " << geometry_rect.ToString();
 }
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithSmallVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
   client_.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
   settings.tiling_interest_area_padding = 1;
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
-  tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, 1.f, pile,
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, 1.f, raster_source,
                                                &client_, settings);
   tiling_->set_resolution(HIGH_RESOLUTION);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   gfx::Rect visible_rect(8000, 8000, 50, 50);
 
   tiling_->ComputeTilePriorityRects(visible_rect,  // visible content rect
                                     1.f,           // current contents scale
                                     1.0,           // current frame time
@@ skipping 13 matching lines @@
   gfx::Size current_layer_bounds(200, 200);
   float current_layer_contents_scale = 1.f;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          current_layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(current_layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
@@ skipping 30 matching lines @@
   double current_frame_time_in_seconds = 1.0;
 
   current_screen_transform.Translate(850, 0);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          current_layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(current_layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
@@ skipping 40 matching lines @@
   double current_frame_time_in_seconds = 1.0;
 
   current_screen_transform.Translate(705, 505);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          current_layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(current_layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
@@ skipping 34 matching lines @@
   // In this configuration, only the top-left tile would be visible.
   current_screen_transform.Translate(600, 750);
   current_screen_transform.RotateAboutZAxis(45);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          current_layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(current_layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
@@ skipping 59 matching lines @@
   MathUtil::MapQuad(current_screen_transform,
                     gfx::QuadF(gfx::RectF(0, 0, 200, 200)),
                     &clipped);
   ASSERT_FALSE(clipped);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          current_layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(current_layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
@@ skipping 69 matching lines @@
   MathUtil::MapQuad(current_screen_transform,
                     gfx::QuadF(gfx::RectF(100, 0, 100, 200)),
                     &clipped);
   ASSERT_FALSE(clipped);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          current_layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(current_layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
@@ skipping 39 matching lines @@
   // Offscreen layer is coming closer to viewport at 1000 pixels per second.
   current_screen_transform.Translate(1800, 0);
   last_screen_transform.Translate(2800, 0);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          current_layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(current_layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                         settings);
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                         &client, settings);
   tiling->set_resolution(HIGH_RESOLUTION);
 
   // previous ("last") frame
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    last_layer_contents_scale,
                                    last_frame_time_in_seconds, Occlusion());
 
   // current frame
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
@@ skipping 53 matching lines @@
   current_screen_transform.Translate(400, 550);
   current_screen_transform.RotateAboutZAxis(45);
 
   last_screen_transform.Translate(400, 550);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          current_layer_bounds);
-  tiling = TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
-                                              LayerTreeSettings());
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(current_layer_bounds);
+  tiling = TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
+                                              &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   // previous ("last") frame
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    last_layer_contents_scale,
                                    last_frame_time_in_seconds, Occlusion());
 
   // current frame
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
@@ skipping 27 matching lines @@
   // - Viewport moves back and a new active tiling tile is created.
   // Result:
   // - Recycle tiling does _not_ have the tile in the same location (thus it
   //   will be shared next time a pending tiling is created).
 
   FakePictureLayerTilingClient active_client;
 
   active_client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          gfx::Size(10000, 10000));
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(gfx::Size(10000, 10000));
   scoped_ptr<TestablePictureLayerTiling> active_tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile,
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &active_client, settings);
   active_tiling->set_resolution(HIGH_RESOLUTION);
   // Create all tiles on this tiling.
   active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 1.0f,
                                           Occlusion());
 
   FakePictureLayerTilingClient recycle_client;
   recycle_client.SetTileSize(gfx::Size(100, 100));
   recycle_client.set_twin_tiling(active_tiling.get());
 
-  pile = FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-      gfx::Size(10000, 10000));
+  raster_source =
+      FakeDisplayListRasterSource::CreateFilled(gfx::Size(10000, 10000));
   scoped_ptr<TestablePictureLayerTiling> recycle_tiling =
-      TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, pile,
+      TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, raster_source,
                                          &recycle_client, settings);
   recycle_tiling->set_resolution(HIGH_RESOLUTION);
 
   // Create all tiles on the second tiling. All tiles should be shared.
   recycle_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f,
                                            1.0f, Occlusion());
 
   // Set the second tiling as recycled.
   active_client.set_twin_tiling(NULL);
   recycle_client.set_twin_tiling(NULL);
@@ skipping 14 matching lines @@
 
   // Ensure that we now have a tile here on both active.
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 }
 
 TEST(PictureLayerTilingTest, RecycledTilesClearedOnReset) {
   FakePictureLayerTilingClient active_client;
   active_client.SetTileSize(gfx::Size(100, 100));
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          gfx::Size(100, 100));
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(gfx::Size(100, 100));
   scoped_ptr<TestablePictureLayerTiling> active_tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile,
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &active_client, LayerTreeSettings());
   active_tiling->set_resolution(HIGH_RESOLUTION);
   // Create all tiles on this tiling.
   active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 1.0f,
                                           Occlusion());
 
   FakePictureLayerTilingClient recycle_client;
   recycle_client.SetTileSize(gfx::Size(100, 100));
   recycle_client.set_twin_tiling(active_tiling.get());
 
   LayerTreeSettings settings;
 
-  pile = FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-      gfx::Size(100, 100));
+  raster_source =
+      FakeDisplayListRasterSource::CreateFilled(gfx::Size(100, 100));
   scoped_ptr<TestablePictureLayerTiling> recycle_tiling =
-      TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, pile,
+      TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, raster_source,
                                          &recycle_client, settings);
   recycle_tiling->set_resolution(HIGH_RESOLUTION);
 
   // Create all tiles on the recycle tiling. All tiles should be shared.
   recycle_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f,
                                            1.0f, Occlusion());
 
   // Set the second tiling as recycled.
   active_client.set_twin_tiling(NULL);
   recycle_client.set_twin_tiling(NULL);
@@ skipping 15 matching lines @@
   EXPECT_EQ(100, tiling_->TilingDataForTesting().max_texture_size().height());
   EXPECT_EQ(4u, tiling_->AllTilesForTesting().size());
 
   client_.SetTileSize(gfx::Size(250, 200));
 
   // Tile size in the tiling should still be 150x100.
   EXPECT_EQ(150, tiling_->TilingDataForTesting().max_texture_size().width());
   EXPECT_EQ(100, tiling_->TilingDataForTesting().max_texture_size().height());
 
   // The layer's size isn't changed, but the tile size was.
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
-          gfx::Size(250, 150));
-  tiling_->SetRasterSourceAndResize(pile);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(gfx::Size(250, 150));
+  tiling_->SetRasterSourceAndResize(raster_source);
 
   // Tile size in the tiling should be resized to 250x200.
   EXPECT_EQ(250, tiling_->TilingDataForTesting().max_texture_size().width());
   EXPECT_EQ(200, tiling_->TilingDataForTesting().max_texture_size().height());
   EXPECT_EQ(0u, tiling_->AllTilesForTesting().size());
 }
 
 // This test runs into floating point issues because of big numbers.
 TEST_F(PictureLayerTilingIteratorTest, GiantRect) {
   gfx::Size tile_size(256, 256);
   gfx::Size layer_size(33554432, 33554432);
-  bool filled = false;
   float contents_scale = 1.f;
 
   client_.SetTileSize(tile_size);
-  scoped_refptr<FakePicturePileImpl> pile = FakePicturePileImpl::CreatePile(
-      tile_size, layer_size, gfx::Rect(), filled);
-  tiling_ = TestablePictureLayerTiling::Create(
-      PENDING_TREE, contents_scale, pile, &client_, LayerTreeSettings());
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_size);

[danakj, 2015/09/22 21:52:15]

before it was not filled (false), the test still works tho right?

[vmpstr, 2015/09/22 22:57:50]

I don't think it matters whether it's filled or not, it's testing coverage on
large numbers. I've changed this to empty.

+  tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, contents_scale,
+                                               raster_source, &client_,
+                                               LayerTreeSettings());
 
   gfx::Rect content_rect(25554432, 25554432, 950, 860);
   VerifyTilesExactlyCoverRect(contents_scale, content_rect);
 }
 
 }  // namespace
 }  // namespace cc