cc: Remove PicturePile and PicturePileImpl.

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 1628c0c5c76f384b3554af4c6afd3f333ee047fb..296beb3cb65dcf9aa11ac4ec57ce8f90c43f925b 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -18,11 +18,12 @@
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_content_layer_client.h"
+#include "cc/test/fake_display_list_raster_source.h"
+#include "cc/test/fake_display_list_recording_source.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_picture_layer_impl.h"
-#include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/gpu_rasterization_enabled_settings.h"
 #include "cc/test/layer_test_common.h"
@@ -125,26 +126,23 @@ class PictureLayerImplTest : public testing::Test {
   }
 
   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
-    gfx::Size tile_size(100, 100);
+    scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+    scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-    scoped_refptr<FakePicturePileImpl> pending_pile =
-        FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-    scoped_refptr<FakePicturePileImpl> active_pile =
-        FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
-    SetupTrees(pending_pile, active_pile);
+    SetupTrees(pending_raster_source, active_raster_source);
   }
 
   void SetupDefaultTreesWithInvalidation(const gfx::Size& layer_bounds,
                                          const Region& invalidation) {
-    gfx::Size tile_size(100, 100);
-
-    scoped_refptr<FakePicturePileImpl> pending_pile =
-        FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-    scoped_refptr<FakePicturePileImpl> active_pile =
-        FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+    scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+    scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-    SetupTreesWithInvalidation(pending_pile, active_pile, invalidation);
+    SetupTreesWithInvalidation(pending_raster_source, active_raster_source,
+                               invalidation);
   }
 
   void ActivateTree() {
@@ -163,40 +161,41 @@ class PictureLayerImplTest : public testing::Test {
   void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
                                           const gfx::Size& tile_size,
                                           const Region& invalidation) {
-    gfx::Size pile_tile_size(100, 100);
-
-    scoped_refptr<FakePicturePileImpl> pending_pile =
-        FakePicturePileImpl::CreateFilledPile(pile_tile_size, layer_bounds);
-    scoped_refptr<FakePicturePileImpl> active_pile =
-        FakePicturePileImpl::CreateFilledPile(pile_tile_size, layer_bounds);
+    scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+    scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-    SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size,
-                                invalidation);
+    SetupTreesWithFixedTileSize(pending_raster_source, active_raster_source,
+                                tile_size, invalidation);
   }
 
-  void SetupTrees(
-      scoped_refptr<PicturePileImpl> pending_pile,
-      scoped_refptr<PicturePileImpl> active_pile) {
-    SetupPendingTree(active_pile);
+  void SetupTrees(scoped_refptr<RasterSource> pending_raster_source,
+                  scoped_refptr<RasterSource> active_raster_source) {
+    SetupPendingTree(active_raster_source);
     ActivateTree();
-    SetupPendingTreeInternal(pending_pile, gfx::Size(), Region());
+    SetupPendingTreeInternal(pending_raster_source, gfx::Size(), Region());
   }
 
-  void SetupTreesWithInvalidation(scoped_refptr<PicturePileImpl> pending_pile,
-                                  scoped_refptr<PicturePileImpl> active_pile,
-                                  const Region& pending_invalidation) {
-    SetupPendingTreeInternal(active_pile, gfx::Size(), Region());
+  void SetupTreesWithInvalidation(
+      scoped_refptr<RasterSource> pending_raster_source,
+      scoped_refptr<RasterSource> active_raster_source,
+      const Region& pending_invalidation) {
+    SetupPendingTreeInternal(active_raster_source, gfx::Size(), Region());
     ActivateTree();
-    SetupPendingTreeInternal(pending_pile, gfx::Size(), pending_invalidation);
+    SetupPendingTreeInternal(pending_raster_source, gfx::Size(),
+                             pending_invalidation);
   }
 
-  void SetupTreesWithFixedTileSize(scoped_refptr<PicturePileImpl> pending_pile,
-                                   scoped_refptr<PicturePileImpl> active_pile,
-                                   const gfx::Size& tile_size,
-                                   const Region& pending_invalidation) {
-    SetupPendingTreeInternal(active_pile, tile_size, Region());
+  void SetupTreesWithFixedTileSize(
+      scoped_refptr<RasterSource> pending_raster_source,
+      scoped_refptr<RasterSource> active_raster_source,
+      const gfx::Size& tile_size,
+      const Region& pending_invalidation) {
+    SetupPendingTreeInternal(active_raster_source, tile_size, Region());
     ActivateTree();
-    SetupPendingTreeInternal(pending_pile, tile_size, pending_invalidation);
+    SetupPendingTreeInternal(pending_raster_source, tile_size,
+                             pending_invalidation);
   }
 
   void SetupPendingTree(scoped_refptr<RasterSource> raster_source) {
@@ -241,7 +240,7 @@ class PictureLayerImplTest : public testing::Test {
         pending_layer->set_fixed_tile_size(tile_size);
     }
     pending_root->SetHasRenderSurface(true);
-    // The bounds() just mirror the pile size.
+    // The bounds() just mirror the raster source size.
     pending_layer->SetBounds(raster_source->GetSize());
     pending_layer->SetRasterSourceOnPending(raster_source, invalidation);
 
@@ -280,9 +279,9 @@ class PictureLayerImplTest : public testing::Test {
     bool resourceless_software_draw = false;
     layer->UpdateTiles(resourceless_software_draw);
   }
-  static void VerifyAllPrioritizedTilesExistAndHavePile(
+  static void VerifyAllPrioritizedTilesExistAndHaveRasterSource(
       const PictureLayerTiling* tiling,
-      PicturePileImpl* pile) {
+      RasterSource* raster_source) {
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
@@ -292,7 +291,7 @@ class PictureLayerImplTest : public testing::Test {
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
-      EXPECT_EQ(pile, prioritized_tiles[*iter].raster_source());
+      EXPECT_EQ(raster_source, prioritized_tiles[*iter].raster_source());
     }
   }
 
@@ -383,41 +382,49 @@ TEST_F(PictureLayerImplTest, TileGridAlignment) {
   gfx::Size layer_size(settings.default_tile_size.width() * 7 / 2,
                        settings.default_tile_size.height() * 7 / 2);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_size);
 
-  scoped_ptr<FakePicturePile> active_recording =
-      FakePicturePile::CreateFilledPile(layer_size, layer_size);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFromPile(active_recording.get(), nullptr);
+  // Create an active recording source, but make sure it's not solid.

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

this says make sure it's solid

but you then draw 2 rects, one that covers the layer and one that's skipping the
right/bottom row. can you comment on them to explain?

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

It says make sure it's not solid.
The important thing is that two rects are of different size, so the solid color
detection would say that the whole layer is not solid. Otherwise, it falls down
a path that isn't meant to be tested by this.

[danakj, 2015/09/22 23:04:06]

Ya.. reading comprehension. All time low. Thanks :)

+  scoped_ptr<FakeDisplayListRecordingSource> active_recording_source =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(layer_size);
+  active_recording_source->add_draw_rect(gfx::Rect(layer_size));
+  active_recording_source->add_draw_rect(
+      gfx::Rect(0, 0, layer_size.width() - 1, layer_size.height() - 1));
+  active_recording_source->Rerecord();
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          active_recording_source.get(), false);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_raster_source, active_raster_source);
 
-  // Add 1x1 rects at the centers of each tile, then re-record pile contents
+  // Add 1x1 rects at the centers of each tile, then re-record recording source
+  // contents.
   active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
   std::vector<Tile*> tiles =
       active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
   EXPECT_EQ(16u, tiles.size());
   std::vector<SkRect> rects;
   std::vector<Tile*>::const_iterator tile_iter;
+  active_recording_source->reset_draws();
   for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
     gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint();
     gfx::Rect rect(tile_center.x(), tile_center.y(), 1, 1);
-    active_recording->add_draw_rect(rect);
+    active_recording_source->add_draw_rect(rect);
     rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1));
   }
 
   // Force re-raster with newly injected content
-  active_recording->RemoveRecordingAt(0, 0);
-  active_recording->AddRecordingAt(0, 0);
+  active_recording_source->Rerecord();
 
-  scoped_refptr<FakePicturePileImpl> updated_active_pile =
-      FakePicturePileImpl::CreateFromPile(active_recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> updated_active_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          active_recording_source.get(), false);
 
   std::vector<SkRect>::const_iterator rect_iter = rects.begin();
   for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
     MockCanvas mock_canvas(1000, 1000);
-    updated_active_pile->PlaybackToSharedCanvas(
+    updated_active_raster_source->PlaybackToSharedCanvas(
         &mock_canvas, (*tile_iter)->content_rect(), 1.0f);
 
     // This test verifies that when drawing the contents of a specific tile
@@ -431,15 +438,8 @@ TEST_F(PictureLayerImplTest, TileGridAlignment) {
 }
 
 TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
-
-  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, Region());
+  SetupDefaultTrees(layer_bounds);
 
   EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
             active_layer_->tilings()->num_tilings());
@@ -452,15 +452,8 @@ TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
 
 TEST_F(PictureLayerImplTest, ExternalViewportRectForPrioritizingTiles) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
-
-  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, Region());
+  SetupDefaultTrees(layer_bounds);
 
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
@@ -541,16 +534,8 @@ TEST_F(PictureLayerImplTest, ExternalViewportRectForPrioritizingTiles) {
 
 TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
-
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
-
-  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, Region());
+  SetupDefaultTrees(layer_bounds);
 
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
@@ -618,15 +603,8 @@ TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
 
 TEST_F(PictureLayerImplTest, ViewportRectForTilePriorityIsCached) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
-
-  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, Region());
+  SetupDefaultTrees(layer_bounds);
 
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
@@ -667,18 +645,18 @@ TEST_F(PictureLayerImplTest, ViewportRectForTilePriorityIsCached) {
 }
 
 TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   gfx::Rect layer_invalidation(150, 200, 30, 180);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> lost_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> lost_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupPendingTreeWithFixedTileSize(lost_pile, gfx::Size(50, 50), Region());
+  SetupPendingTreeWithFixedTileSize(lost_raster_source, gfx::Size(50, 50),
+                                    Region());
   ActivateTree();
   // Add a unique tiling on the active tree.
   PictureLayerTiling* tiling = active_layer_->AddTiling(3.f);
@@ -689,8 +667,8 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
   active_layer_->MarkAllTilingsUsed();
 
   // Then setup a new pending tree and activate it.
-  SetupTreesWithFixedTileSize(pending_pile, active_pile, gfx::Size(50, 50),
-                              layer_invalidation);
+  SetupTreesWithFixedTileSize(pending_raster_source, active_raster_source,
+                              gfx::Size(50, 50), layer_invalidation);
 
   EXPECT_EQ(1u, pending_layer_->num_tilings());
   EXPECT_EQ(3u, active_layer_->num_tilings());
@@ -714,7 +692,8 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
       // invalidated and it has the latest raster source.
       if (*iter) {
         EXPECT_FALSE(iter.geometry_rect().IsEmpty());
-        EXPECT_EQ(pending_pile.get(), prioritized_tiles[*iter].raster_source());
+        EXPECT_EQ(pending_raster_source.get(),
+                  prioritized_tiles[*iter].raster_source());
         EXPECT_TRUE(iter.geometry_rect().Intersects(content_invalidation));
       } else {
         // We don't create tiles in non-invalidated regions.
@@ -739,22 +718,22 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
-      // Pile will be updated upon activation.
-      EXPECT_EQ(active_pile.get(), prioritized_tiles[*iter].raster_source());
+      // Raster source will be updated upon activation.
+      EXPECT_EQ(active_raster_source.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);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupTreesWithInvalidation(pending_pile, active_pile,
+  SetupTreesWithInvalidation(pending_raster_source, active_raster_source,
                              gfx::Rect(layer_bounds));
 
   EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
@@ -762,21 +741,15 @@ TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
-  for (size_t i = 0; i < tilings->num_tilings(); ++i)
-    VerifyAllPrioritizedTilesExistAndHavePile(tilings->tiling_at(i),
-                                              pending_pile.get());
+  for (size_t i = 0; i < tilings->num_tilings(); ++i) {
+    VerifyAllPrioritizedTilesExistAndHaveRasterSource(
+        tilings->tiling_at(i), pending_raster_source.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);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
@@ -844,15 +817,8 @@ TEST_F(PictureLayerImplTest, UpdateTilesCreatesTilings) {
 }
 
 TEST_F(PictureLayerImplTest, PendingLayerOnlyHasHighResTiling) {
-  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);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
@@ -915,19 +881,18 @@ TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
   // This test makes sure that if a layer can have tilings, then a commit makes
   // it not able to have tilings (empty size), and then a future commit that
   // makes it valid again should be able to create tilings.
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
-  scoped_refptr<FakePicturePileImpl> empty_pile =
-      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> valid_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> empty_raster_source =
+      FakeDisplayListRasterSource::CreateEmpty(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> valid_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupPendingTree(valid_pile);
+  SetupPendingTree(valid_raster_source);
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
 
   ActivateTree();
-  SetupPendingTree(empty_pile);
+  SetupPendingTree(empty_raster_source);
   EXPECT_FALSE(pending_layer_->CanHaveTilings());
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, pending_layer_->tilings()->num_tilings());
@@ -936,25 +901,24 @@ TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
   EXPECT_FALSE(active_layer_->CanHaveTilings());
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
 
-  SetupPendingTree(valid_pile);
+  SetupPendingTree(valid_raster_source);
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, LowResTilingStaysOnActiveTree) {
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
-  scoped_refptr<FakePicturePileImpl> valid_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> other_valid_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> valid_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> other_valid_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupPendingTree(valid_pile);
+  SetupPendingTree(valid_raster_source);
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
 
   ActivateTree();
-  SetupPendingTree(other_valid_pile);
+  SetupPendingTree(other_valid_raster_source);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
   auto* low_res_tiling =
@@ -970,16 +934,10 @@ TEST_F(PictureLayerImplTest, LowResTilingStaysOnActiveTree) {
 }
 
 TEST_F(PictureLayerImplTest, ZoomOutCrash) {
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   // Set up the high and low res tilings before pinch zoom.
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
   ResetTilingsAndRasterScales();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   SetContentsScaleOnBothLayers(32.0f, 1.0f, 32.0f, 1.0f, 0.f, false);
@@ -991,18 +949,11 @@ TEST_F(PictureLayerImplTest, ZoomOutCrash) {
 }
 
 TEST_F(PictureLayerImplTest, PinchGestureTilings) {
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
-
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
   // Set up the high and low res tilings before pinch zoom.
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
   ResetTilingsAndRasterScales();
 
   SetContentsScaleOnBothLayers(2.f, 1.0f, 2.f, 1.0f, 0.f, false);
@@ -1080,15 +1031,8 @@ TEST_F(PictureLayerImplTest, PinchGestureTilings) {
 }
 
 TEST_F(PictureLayerImplTest, SnappedTilingDuringZoom) {
-  gfx::Size tile_size(300, 300);
   gfx::Size layer_bounds(2600, 3800);
-
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
 
   ResetTilingsAndRasterScales();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
@@ -1140,14 +1084,8 @@ TEST_F(PictureLayerImplTest, SnappedTilingDuringZoom) {
 }
 
 TEST_F(PictureLayerImplTest, CleanUpTilings) {
-  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);
-
   std::vector<PictureLayerTiling*> used_tilings;
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
@@ -1156,7 +1094,7 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
   float scale = 1.f;
   float page_scale = 1.f;
 
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
   EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
   EXPECT_EQ(1.f, active_layer_->HighResTiling()->contents_scale());
 
@@ -1323,14 +1261,13 @@ TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
 
 TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
   gfx::Size layer_bounds(host_impl_.settings().default_tile_size);
-  gfx::Size tile_size(100, 100);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_raster_source, active_raster_source);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   float device_scale = 1.f;
@@ -1375,7 +1312,7 @@ TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
   // Mask layers dont create low res since they always fit on one tile.
   scoped_ptr<FakePictureLayerImpl> mask =
       FakePictureLayerImpl::CreateMaskWithRasterSource(
-          host_impl_.pending_tree(), 3, pending_pile);
+          host_impl_.pending_tree(), 3, pending_raster_source);
   mask->SetBounds(layer_bounds);
   mask->SetDrawsContent(true);
 
@@ -1389,16 +1326,15 @@ TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
 TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  scoped_refptr<FakePicturePileImpl> valid_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(valid_pile);
+  scoped_refptr<FakeDisplayListRasterSource> valid_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTree(valid_raster_source);
 
   scoped_ptr<FakePictureLayerImpl> mask_ptr =
       FakePictureLayerImpl::CreateMaskWithRasterSource(
-          host_impl_.pending_tree(), 3, valid_pile);
+          host_impl_.pending_tree(), 3, valid_raster_source);
   mask_ptr->SetBounds(layer_bounds);
   mask_ptr->SetDrawsContent(true);
   pending_layer_->SetMaskLayer(mask_ptr.Pass());
@@ -1447,12 +1383,12 @@ TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) {
   // Resize larger than the max texture size.
   int max_texture_size = host_impl_.GetRendererCapabilities().max_texture_size;
   gfx::Size huge_bounds(max_texture_size + 1, 10);
-  scoped_refptr<FakePicturePileImpl> huge_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, huge_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> huge_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(huge_bounds);
 
-  SetupPendingTree(huge_pile);
+  SetupPendingTree(huge_raster_source);
   pending_mask->SetBounds(huge_bounds);
-  pending_mask->SetRasterSourceOnPending(huge_pile, Region());
+  pending_mask->SetRasterSourceOnPending(huge_raster_source, Region());
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
@@ -1488,7 +1424,7 @@ TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) {
   EXPECT_EQ(expected_size, mask_texture_size);
 
   // Do another activate, the same holds.
-  SetupPendingTree(huge_pile);
+  SetupPendingTree(huge_raster_source);
   ActivateTree();
   EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
   active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
@@ -1499,12 +1435,12 @@ TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) {
   // contents scale. Then the layer should no longer have any tiling.
   float min_contents_scale = host_impl_.settings().minimum_contents_scale;
   gfx::Size extra_huge_bounds(max_texture_size / min_contents_scale + 1, 10);
-  scoped_refptr<FakePicturePileImpl> extra_huge_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, extra_huge_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> extra_huge_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(extra_huge_bounds);
 
-  SetupPendingTree(extra_huge_pile);
+  SetupPendingTree(extra_huge_raster_source);
   pending_mask->SetBounds(extra_huge_bounds);
-  pending_mask->SetRasterSourceOnPending(extra_huge_pile, Region());
+  pending_mask->SetRasterSourceOnPending(extra_huge_raster_source, Region());
 
   EXPECT_FALSE(pending_mask->CanHaveTilings());
 
@@ -1517,18 +1453,17 @@ TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) {
 TEST_F(PictureLayerImplTest, ScaledMaskLayer) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
   host_impl_.SetDeviceScaleFactor(1.3f);
 
-  scoped_refptr<FakePicturePileImpl> valid_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(valid_pile);
+  scoped_refptr<FakeDisplayListRasterSource> valid_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTree(valid_raster_source);
 
   scoped_ptr<FakePictureLayerImpl> mask_ptr =
       FakePictureLayerImpl::CreateMaskWithRasterSource(
-          host_impl_.pending_tree(), 3, valid_pile);
+          host_impl_.pending_tree(), 3, valid_raster_source);
   mask_ptr->SetBounds(layer_bounds);
   mask_ptr->SetDrawsContent(true);
   pending_layer_->SetMaskLayer(mask_ptr.Pass());
@@ -1567,15 +1502,8 @@ TEST_F(PictureLayerImplTest, ScaledMaskLayer) {
 }
 
 TEST_F(PictureLayerImplTest, ReleaseResources) {
-  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);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
 
   // All tilings should be removed when losing output surface.
@@ -1600,14 +1528,12 @@ TEST_F(PictureLayerImplTest, ReleaseResources) {
 }
 
 TEST_F(PictureLayerImplTest, ClampTilesToMaxTileSize) {
-  // The default max tile size is larger than 400x400.
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(5000, 5000);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_raster_source);
   EXPECT_GE(pending_layer_->tilings()->num_tilings(), 1u);
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
@@ -1643,16 +1569,8 @@ TEST_F(PictureLayerImplTest, ClampTilesToMaxTileSize) {
 }
 
 TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
-  // The default max tile size is larger than 400x400.
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(500, 500);
-
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
   EXPECT_GE(active_layer_->tilings()->num_tilings(), 1u);
 
   active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
@@ -1695,17 +1613,11 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
 TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
   gfx::Rect layer_rect(layer_bounds);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
   gfx::Rect layer_invalidation(150, 200, 30, 180);
-  SetupTreesWithInvalidation(pending_pile, active_pile, layer_invalidation);
+  SetupDefaultTreesWithInvalidation(layer_bounds, layer_invalidation);
 
   active_layer_->SetContentsOpaque(true);
   active_layer_->draw_properties().visible_layer_rect = gfx::Rect(layer_bounds);
@@ -1715,7 +1627,7 @@ TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
-  ASSERT_EQ(1U, render_pass->quad_list.size());
+  ASSERT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(DrawQuad::PICTURE_CONTENT,
             render_pass->quad_list.front()->material);
   EXPECT_EQ(render_pass->quad_list.front()->rect, layer_rect);
@@ -1732,11 +1644,20 @@ TEST_F(PictureLayerImplTest, ResourcelessPartialRecording) {
   host_impl_.SetDeviceScaleFactor(2.f);
 
   gfx::Rect recorded_viewport(20, 30, 40, 50);
-  bool is_filled = true;
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreatePile(tile_size, layer_bounds,
-                                      recorded_viewport, is_filled);
-  SetupPendingTree(active_pile);
+  scoped_ptr<FakeDisplayListRecordingSource> active_recording_source =
+      FakeDisplayListRecordingSource::CreateRecordingSource(recorded_viewport,
+                                                            layer_bounds);
+  SkPaint green_paint;
+  green_paint.setColor(SK_ColorGREEN);

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

can you comment why is green important? maybe in combination with
recorded_viewport != layer_bounds?

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

I changed this to use CreatePartiallyFilled

+  active_recording_source->add_draw_rect_with_paint(recorded_viewport,
+                                                    green_paint);
+  active_recording_source->Rerecord();
+
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          active_recording_source.get(), true);
+
+  SetupPendingTree(active_raster_source);
   ActivateTree();
 
   active_layer_->SetContentsOpaque(true);
@@ -1764,12 +1685,11 @@ TEST_F(PictureLayerImplTest, ResourcelessPartialRecording) {
 TEST_F(PictureLayerImplTest, ResourcelessEmptyRecording) {
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(700, 650);
-
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
-  SetupPendingTree(active_pile);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreatePartiallyFilled(layer_bounds,
+                                                         gfx::Rect());
+  SetupPendingTree(active_raster_source);
   ActivateTree();
 
   active_layer_->SetContentsOpaque(true);
@@ -1790,16 +1710,25 @@ TEST_F(PictureLayerImplTest, SolidColorLayerHasVisibleFullCoverage) {
   gfx::Size layer_bounds(1500, 1500);
   gfx::Rect visible_rect(250, 250, 1000, 1000);
 
-  scoped_ptr<FakePicturePile> empty_recording =
-      FakePicturePile::CreateEmptyPile(tile_size, layer_bounds);
-  empty_recording->SetIsSolidColor(true);
+  scoped_ptr<FakeDisplayListRecordingSource> empty_recording =
+      FakeDisplayListRecordingSource::CreateRecordingSource(
+          gfx::Rect(layer_bounds), layer_bounds);
+  SkPaint red_paint;
+  red_paint.setColor(SK_ColorRED);
+  empty_recording->add_draw_rect_with_paint(gfx::Rect(layer_bounds), red_paint);

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

doesn't look so empty. solid_fill_recording?

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

I changed this to use CreateFilledSolidColor

[danakj, 2015/09/22 23:04:06]

Nice.

+  empty_recording->Rerecord();
+
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          empty_recording.get(), false);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          empty_recording.get(), false);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFromPile(empty_recording.get(), nullptr);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFromPile(empty_recording.get(), nullptr);
+  EXPECT_TRUE(pending_raster_source->IsSolidColor());
+  EXPECT_TRUE(active_raster_source->IsSolidColor());
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_raster_source, active_raster_source);
 
   active_layer_->draw_properties().visible_layer_rect = visible_rect;
 
@@ -1818,29 +1747,27 @@ TEST_F(PictureLayerImplTest, SolidColorLayerHasVisibleFullCoverage) {
   EXPECT_TRUE(remaining.IsEmpty());
 }
 
-TEST_F(PictureLayerImplTest, TileScalesWithSolidColorPile) {
+TEST_F(PictureLayerImplTest, TileScalesWithSolidColorRasterSource) {
   gfx::Size layer_bounds(200, 200);
   gfx::Size tile_size(host_impl_.settings().default_tile_size);
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
-          tile_size, layer_bounds, false);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
-          tile_size, layer_bounds, true);
-
-  SetupTrees(pending_pile, active_pile);
-  // Solid color pile should not allow tilings at any scale.
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilledSolidColor(layer_bounds);
+
+  SetupTrees(pending_raster_source, active_raster_source);
+  // Solid color raster source should not allow tilings at any scale.
   EXPECT_FALSE(active_layer_->CanHaveTilings());
   EXPECT_EQ(0.f, active_layer_->ideal_contents_scale());
 
-  // Activate non-solid-color pending pile makes active layer can have tilings.
+  // Activate non-solid-color pending raster source makes active layer can have
+  // tilings.
   ActivateTree();
   EXPECT_TRUE(active_layer_->CanHaveTilings());
   EXPECT_GT(active_layer_->ideal_contents_scale(), 0.f);
 }
 
 TEST_F(NoLowResPictureLayerImplTest, MarkRequiredOffscreenTiles) {
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
   gfx::Transform transform;
@@ -1854,9 +1781,10 @@ TEST_F(NoLowResPictureLayerImplTest, MarkRequiredOffscreenTiles) {
                                         transform,
                                         resourceless_software_draw);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, gfx::Size(100, 100),
+                                    Region());
 
   EXPECT_EQ(1u, pending_layer_->num_tilings());
   EXPECT_EQ(viewport, pending_layer_->visible_rect_for_tile_priority());
@@ -1895,11 +1823,7 @@ TEST_F(NoLowResPictureLayerImplTest,
   gfx::Rect external_viewport_for_tile_priority(400, 200);
   gfx::Rect visible_layer_rect(200, 400);
 
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   ASSERT_EQ(1u, pending_layer_->num_tilings());
   ASSERT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
@@ -1978,10 +1902,10 @@ TEST_F(PictureLayerImplTest, HighResTileIsComplete) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ActivateTree();
 
   // All high res tiles have resources.
@@ -2008,9 +1932,9 @@ TEST_F(PictureLayerImplTest, HighResTileIsIncomplete) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ActivateTree();
 
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
@@ -2031,9 +1955,9 @@ TEST_F(PictureLayerImplTest, HighResTileIsIncompleteLowResComplete) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ActivateTree();
 
   std::vector<Tile*> low_tiles =
@@ -2058,9 +1982,9 @@ TEST_F(PictureLayerImplTest, LowResTileIsIncomplete) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ActivateTree();
 
   // All high res tiles have resources except one.
@@ -2098,11 +2022,7 @@ TEST_F(PictureLayerImplTest,
   host_impl_.SetViewportSize(viewport_size);
   host_impl_.SetDeviceScaleFactor(2.f);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   // One ideal tile exists, this will get used when drawing.
   std::vector<Tile*> ideal_tiles;
@@ -2244,18 +2164,18 @@ TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  // This pile will create tilings, but has no recordings so will not create any
-  // tiles.  This is attempting to simulate scrolling past the end of recorded
-  // content on the active layer, where the recordings are so far away that
-  // no tiles are created.
-  bool is_solid_color = false;
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
-          tile_size, layer_bounds, is_solid_color);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  // This raster source will create tilings, but has no recordings so will not
+  // create any tiles.  This is attempting to simulate scrolling past the end of
+  // recorded content on the active layer, where the recordings are so far away
+  // that no tiles are created.
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreatePartiallyFilled(layer_bounds,
+                                                         gfx::Rect());
 
-  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
+  SetupTreesWithFixedTileSize(pending_raster_source, active_raster_source,
+                              tile_size, Region());
 
   // Active layer has tilings, but no tiles due to missing recordings.
   EXPECT_TRUE(active_layer_->CanHaveTilings());
@@ -2274,11 +2194,12 @@ TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
-  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateEmpty(layer_bounds);
+  SetupTreesWithFixedTileSize(pending_raster_source, active_raster_source,
+                              tile_size, Region());
 
   // Active layer can't have tiles.
   EXPECT_FALSE(active_layer_->CanHaveTilings());
@@ -2298,12 +2219,13 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenActiveHasDifferentBounds) {
   gfx::Size active_layer_bounds(200, 200);
   gfx::Size tile_size(100, 100);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, pending_layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(pending_layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(active_layer_bounds);
 
-  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
+  SetupTreesWithFixedTileSize(pending_raster_source, active_raster_source,
+                              tile_size, Region());
 
   // Since the active layer has different bounds, the pending layer needs all
   // high res tiles in order to activate.
@@ -2318,17 +2240,16 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenActiveHasDifferentBounds) {
 }
 
 TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
   host_impl_.CreatePendingTree();
   LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 
   scoped_ptr<FakePictureLayerImpl> pending_layer =
       FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_,
-                                                   pending_pile);
+                                                   pending_raster_source);
   pending_layer->SetDrawsContent(true);
   pending_tree->SetRootLayer(pending_layer.Pass());
 
@@ -2353,12 +2274,11 @@ TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
 
 TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
   gfx::Size layer_bounds(1500, 1500);
-  gfx::Size tile_size(100, 100);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_raster_source);
 
   PictureLayerTiling* tiling = pending_layer_->HighResTiling();
   gfx::Rect first_invalidate = tiling->TilingDataForTesting().TileBounds(0, 0);
@@ -2371,18 +2291,16 @@ TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
   ActivateTree();
 
   // Make a pending tree with an invalidated raster tile 0,0.
-  SetupPendingTreeWithInvalidation(pending_pile, first_invalidate);
+  SetupPendingTreeWithInvalidation(pending_raster_source, first_invalidate);
 
   // Activate and make a pending tree with an invalidated raster tile 1,1.
   ActivateTree();
 
-  SetupPendingTreeWithInvalidation(pending_pile, second_invalidate);
+  SetupPendingTreeWithInvalidation(pending_raster_source, second_invalidate);
 
   PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
   PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
 
-  // pending_tiling->CreateAllTilesForTesting();

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

heh oops *^_^*

-
   // Tile 0,0 not exist on pending, but tile 1,1 should.
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_TRUE(active_tiling->TileAt(1, 0));
@@ -2435,20 +2353,20 @@ TEST_F(PictureLayerImplTest, PendingHasNoTilesWithNoInvalidation) {
 }
 
 TEST_F(PictureLayerImplTest, ShareInvalidActiveTreeTiles) {
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1500, 1500);
 
-  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(1, 1));
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupTreesWithInvalidation(pending_raster_source, active_raster_source,
+                             gfx::Rect(1, 1));
   // Activate the invalidation.
   ActivateTree();
   // Make another pending tree without any invalidation in it.
-  scoped_refptr<FakePicturePileImpl> pending_pile2 =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile2);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source2 =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTree(pending_raster_source2);
 
   EXPECT_GE(active_layer_->num_tilings(), 1u);
   EXPECT_GE(pending_layer_->num_tilings(), 1u);
@@ -2500,15 +2418,14 @@ TEST_F(PictureLayerImplTest, RecreateInvalidPendingTreeTiles) {
 TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(10, 10);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_raster_source, active_raster_source);
 
   EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.f));
   EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(1.f));
@@ -2532,7 +2449,7 @@ TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
   ActivateTree();
   EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(1.f));
 
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_raster_source);
   EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.f));
 
   // Toggling the gpu rasterization clears all tilings on both trees.
@@ -2551,14 +2468,12 @@ TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
 }
 
 TEST_F(PictureLayerImplTest, HighResCreatedWhenBoundsShrink) {
-  gfx::Size tile_size(100, 100);
-
   // Put 0.5 as high res.
   host_impl_.SetDeviceScaleFactor(0.5f);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(10, 10));
-  SetupPendingTree(pending_pile);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(gfx::Size(10, 10));
+  SetupPendingTree(pending_raster_source);
 
   // Sanity checks.
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
@@ -2567,9 +2482,9 @@ TEST_F(PictureLayerImplTest, HighResCreatedWhenBoundsShrink) {
   ActivateTree();
 
   // Now, set the bounds to be 1x1, so that minimum contents scale becomes 1.
-  pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1, 1));
-  SetupPendingTree(pending_pile);
+  pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(gfx::Size(1, 1));
+  SetupPendingTree(pending_raster_source);
 
   // Another sanity check.
   EXPECT_EQ(1.f, pending_layer_->MinimumContentsScale());
@@ -2982,13 +2897,12 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
 
   host_impl_.SetViewportSize(gfx::Size(500, 500));
 
-  gfx::Size recording_tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(recording_tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_raster_source);
   EXPECT_EQ(1u, pending_layer_->num_tilings());
 
   std::set<Tile*> unique_tiles;
@@ -3116,13 +3030,12 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueueActiveTree) {
 
   host_impl_.SetViewportSize(gfx::Size(500, 500));
 
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_raster_source);
   ActivateTree();
   EXPECT_EQ(2u, active_layer_->num_tilings());
 
@@ -3145,15 +3058,11 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueueActiveTree) {
 }
 
 TEST_F(PictureLayerImplTest, TilingSetRasterQueueRequiredNoHighRes) {
-  scoped_ptr<FakePicturePile> empty_recording =
-      FakePicturePile::CreateEmptyPile(gfx::Size(256, 256),
-                                       gfx::Size(1024, 1024));
-  empty_recording->SetIsSolidColor(true);
-
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFromPile(empty_recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilledSolidColor(
+          gfx::Size(1024, 1024));
 
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_raster_source);
   EXPECT_FALSE(
       pending_layer_->picture_layer_tiling_set()->FindTilingWithResolution(
           HIGH_RESOLUTION));
@@ -3166,18 +3075,17 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueueRequiredNoHighRes) {
 }
 
 TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
 
   host_impl_.SetViewportSize(gfx::Size(500, 500));
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
   // TODO(vmpstr): Add a test with tilings other than high res on the active
   // tree (crbug.com/519607).
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_raster_source);
   EXPECT_EQ(1u, pending_layer_->num_tilings());
 
   std::vector<Tile*> all_tiles;
@@ -3317,9 +3225,9 @@ TEST_F(PictureLayerImplTest, Occlusion) {
   LayerTestCommon::LayerImplTest impl;
   host_impl_.SetViewportSize(viewport_size);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(layer_bounds, layer_bounds);
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ActivateTree();
 
   std::vector<Tile*> tiles =
@@ -3460,15 +3368,8 @@ TEST_F(PictureLayerImplTest, ActiveHighResReadyNotEnoughToActivate) {
 }
 
 TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
-  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);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
@@ -3525,15 +3426,8 @@ TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
 }
 
 TEST_F(NoLowResPictureLayerImplTest, PendingLayerOnlyHasHighResTiling) {
-  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);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
@@ -3617,18 +3511,18 @@ TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  // This pile will create tilings, but has no recordings so will not create any
-  // tiles.  This is attempting to simulate scrolling past the end of recorded
-  // content on the active layer, where the recordings are so far away that
-  // no tiles are created.
-  bool is_solid_color = false;
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
-          tile_size, layer_bounds, is_solid_color);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  // This raster source will create tilings, but has no recordings so will not
+  // create any tiles.  This is attempting to simulate scrolling past the end of
+  // recorded content on the active layer, where the recordings are so far away
+  // that no tiles are created.
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreatePartiallyFilled(layer_bounds,
+                                                         gfx::Rect());
 
-  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
+  SetupTreesWithFixedTileSize(pending_raster_source, active_raster_source,
+                              tile_size, Region());
 
   // Active layer has tilings, but no tiles due to missing recordings.
   EXPECT_TRUE(active_layer_->CanHaveTilings());
@@ -3649,16 +3543,8 @@ TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
 
 TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
-
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
-
-  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, Region());
+  SetupDefaultTrees(layer_bounds);
 
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
@@ -3725,17 +3611,9 @@ TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
 }
 
 TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
-  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);
-
   std::vector<PictureLayerTiling*> used_tilings;
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
@@ -3842,15 +3720,8 @@ TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
 }
 
 TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
-  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);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
   EXPECT_EQ(1u, active_layer_->tilings()->num_tilings());
 
@@ -3878,17 +3749,9 @@ TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
 TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1000, 2000);
-
   host_impl_.SetViewportSize(gfx::Size(10000, 20000));
-
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
 
   ResetTilingsAndRasterScales();
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 2.5f, 1.f, 1.f, 1.f, 0.f,
@@ -3936,13 +3799,12 @@ TEST_F(PictureLayerImplTestWithDelegatingRenderer,
        DelegatingRendererWithTileOOM) {
   // This test is added for crbug.com/402321, where quad should be produced when
   // raster on demand is not allowed and tile is OOM.
-  gfx::Size tile_size = host_impl_.settings().default_tile_size;
   gfx::Size layer_bounds(1000, 1000);
 
   // Create tiles.
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTree(pending_raster_source);
   pending_layer_->SetBounds(layer_bounds);
   ActivateTree();
   bool update_lcd_text = false;
@@ -3957,6 +3819,7 @@ TEST_F(PictureLayerImplTestWithDelegatingRenderer,
   // state. We also need to update tree priority separately.
   GlobalStateThatImpactsTilePriority state;
   size_t max_tiles = 1;
+  gfx::Size tile_size(host_impl_.settings().default_tile_size);
   size_t memory_limit = max_tiles * 4 * tile_size.width() * tile_size.height();
   size_t resource_limit = max_tiles;
   ManagedMemoryPolicy policy(memory_limit,
@@ -4046,9 +3909,9 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   host_impl_.SetViewportSize(viewport_size);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
 
   // No occlusion.
   int unoccluded_tile_count = 0;
@@ -4135,9 +3998,9 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   host_impl_.SetViewportSize(viewport_size);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
 
   // No occlusion.
   int occluded_tile_count = 0;
@@ -4250,12 +4113,12 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, OcclusionForDifferentScales) {
   gfx::Size viewport_size(500, 500);
   gfx::Point occluding_layer_position(310, 0);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
   host_impl_.SetViewportSize(viewport_size);
 
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ASSERT_TRUE(pending_layer_->CanHaveTilings());
 
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
@@ -4324,13 +4187,13 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
   gfx::Point occluding_layer_position(310, 0);
   gfx::Rect invalidation_rect(230, 230, 102, 102);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
   host_impl_.SetViewportSize(viewport_size);
-  SetupPendingTree(active_pile);
+  SetupPendingTree(active_raster_source);
 
   // Partially occlude the active layer.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 2));
@@ -4364,7 +4227,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
   }
 
   // Partially invalidate the pending layer.
-  SetupPendingTreeWithInvalidation(pending_pile, invalidation_rect);
+  SetupPendingTreeWithInvalidation(pending_raster_source, invalidation_rect);
 
   for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
@@ -4418,12 +4281,12 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
   host_impl_.SetViewportSize(viewport_size);
   host_impl_.SetDeviceScaleFactor(2.f);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupPendingTreeWithFixedTileSize(active_pile, tile_size, Region());
+  SetupPendingTreeWithFixedTileSize(active_raster_source, tile_size, Region());
 
   // Partially occlude the active layer.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 2));
@@ -4437,7 +4300,8 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   // Partially invalidate the pending layer. Tiles inside the invalidation rect
   // are created.
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, invalidation_rect);
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size,
+                                    invalidation_rect);
 
   // Partially occlude the pending layer in a different way.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 3));
@@ -4553,18 +4417,17 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 }
 
 TEST_F(PictureLayerImplTest, PendingOrActiveTwinLayer) {
-  gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
 
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pile);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTree(raster_source);
   EXPECT_FALSE(pending_layer_->GetPendingOrActiveTwinLayer());
 
   ActivateTree();
   EXPECT_FALSE(active_layer_->GetPendingOrActiveTwinLayer());
 
-  SetupPendingTree(pile);
+  SetupPendingTree(raster_source);
   EXPECT_TRUE(pending_layer_->GetPendingOrActiveTwinLayer());
   EXPECT_TRUE(active_layer_->GetPendingOrActiveTwinLayer());
   EXPECT_EQ(pending_layer_, active_layer_->GetPendingOrActiveTwinLayer());
@@ -4701,15 +4564,8 @@ TEST_F(PictureLayerImplTest, NonSolidToSolidNoTilings) {
 TEST_F(PictureLayerImplTest, ChangeInViewportAllowsTilingUpdates) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
-  gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 4000);
-
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
 
   Region invalidation;
   gfx::Rect viewport = gfx::Rect(0, 0, 100, 100);
@@ -4767,19 +4623,17 @@ TEST_F(PictureLayerImplTest, CloneMissingRecordings) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
-  scoped_refptr<FakePicturePileImpl> filled_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> filled_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  scoped_ptr<FakePicturePile> partial_recording =
-      FakePicturePile::CreateEmptyPile(tile_size, layer_bounds);
-  for (int i = 1; i < partial_recording->tiling().num_tiles_x(); ++i) {
-    for (int j = 1; j < partial_recording->tiling().num_tiles_y(); ++j)
-      partial_recording->AddRecordingAt(i, j);
-  }
-  scoped_refptr<FakePicturePileImpl> partial_pile =
-      FakePicturePileImpl::CreateFromPile(partial_recording.get(), nullptr);
+  // scoped_ptr<FakeDisplayListRecordingSource> partial_recording =

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

commented out code

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

Removed.

+  //    FakeDisplayListRecordingSource::CreateRecordingSource(
+  //        gfx::Rect(250, 250, 150, 150), layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> partial_raster_source =
+      FakeDisplayListRasterSource::CreatePartiallyFilled(
+          layer_bounds, gfx::Rect(100, 100, 300, 300));
 
-  SetupPendingTreeWithFixedTileSize(filled_pile, tile_size, Region());
+  SetupPendingTreeWithFixedTileSize(filled_raster_source, tile_size, Region());
   ActivateTree();
 
   PictureLayerTiling* pending_tiling = old_pending_layer_->HighResTiling();
@@ -4789,10 +4643,10 @@ TEST_F(PictureLayerImplTest, CloneMissingRecordings) {
   EXPECT_EQ(0u, pending_tiling->AllTilesForTesting().size());
   EXPECT_EQ(5u * 5u, active_tiling->AllTilesForTesting().size());
 
-  // Now put a partially-recorded pile on the pending tree (and invalidate
-  // everything, since the main thread PicturePile will invalidate dropped
-  // recordings). This will cause us to be missing some tiles.
-  SetupPendingTreeWithFixedTileSize(partial_pile, tile_size,
+  // Now put a partially-recorded raster source on the pending tree (and
+  // invalidate everything, since the main thread recording will invalidate
+  // dropped recordings). This will cause us to be missing some tiles.
+  SetupPendingTreeWithFixedTileSize(partial_raster_source, tile_size,
                                     Region(gfx::Rect(layer_bounds)));
   EXPECT_EQ(3u * 3u, pending_tiling->AllTilesForTesting().size());
   EXPECT_FALSE(pending_tiling->TileAt(0, 0));
@@ -4811,7 +4665,7 @@ TEST_F(PictureLayerImplTest, CloneMissingRecordings) {
 
   // Now put a full recording on the pending tree again. We'll get all our tiles
   // back.
-  SetupPendingTreeWithFixedTileSize(filled_pile, tile_size,
+  SetupPendingTreeWithFixedTileSize(filled_raster_source, tile_size,
                                     Region(gfx::Rect(layer_bounds)));
   EXPECT_EQ(5u * 5u, pending_tiling->AllTilesForTesting().size());
   Tile* tile00 = pending_tiling->TileAt(0, 0);
@@ -4839,12 +4693,12 @@ TEST_F(PictureLayerImplTest, ScrollPastLiveTilesRectAndBack) {
   host_impl_.SetViewportSize(viewport_size);
   host_impl_.SetDeviceScaleFactor(1.f);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
 
-  SetupPendingTreeWithFixedTileSize(active_pile, tile_size, Region());
+  SetupPendingTreeWithFixedTileSize(active_raster_source, tile_size, Region());
 
   ActivateTree();
   EXPECT_TRUE(active_layer_->HighResTiling()->has_tiles());
@@ -4857,7 +4711,8 @@ TEST_F(PictureLayerImplTest, ScrollPastLiveTilesRectAndBack) {
       gfx::Transform(),              // transform_for_tile_priority
       false);
 
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, gfx::Rect());
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size,
+                                    gfx::Rect());
 
   EXPECT_FALSE(pending_layer_->HighResTiling()->has_tiles());
   EXPECT_TRUE(pending_layer_->HighResTiling()->live_tiles_rect().IsEmpty());
@@ -4873,7 +4728,8 @@ TEST_F(PictureLayerImplTest, ScrollPastLiveTilesRectAndBack) {
       gfx::Transform(),             // transform_for_tile_priority
       false);
 
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, gfx::Rect());
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size,
+                                    gfx::Rect());
 
   EXPECT_FALSE(pending_layer_->HighResTiling()->has_tiles());
   EXPECT_FALSE(pending_layer_->HighResTiling()->live_tiles_rect().IsEmpty());
@@ -4885,19 +4741,13 @@ TEST_F(PictureLayerImplTest, ScrollPastLiveTilesRectAndBack) {
 TEST_F(PictureLayerImplTest, ScrollPropagatesToPending) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
-  gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
   gfx::Size viewport_size(100, 100);
 
   host_impl_.SetViewportSize(viewport_size);
   host_impl_.SetDeviceScaleFactor(1.f);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
 
   active_layer_->SetCurrentScrollOffset(gfx::ScrollOffset(0.0, 50.0));
   host_impl_.active_tree()->UpdateDrawProperties(false);
@@ -4924,9 +4774,9 @@ TEST_F(PictureLayerImplTest, UpdateLCDInvalidatesPendingTree) {
   host_impl_.SetViewportSize(viewport_size);
   host_impl_.SetDeviceScaleFactor(1.f);
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilledLCD(layer_bounds);
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
 
   EXPECT_TRUE(pending_layer_->RasterSourceUsesLCDText());
   EXPECT_TRUE(pending_layer_->HighResTiling()->has_tiles());
@@ -4943,7 +4793,7 @@ TEST_F(PictureLayerImplTest, UpdateLCDInvalidatesPendingTree) {
   pending_layer_->UpdateCanUseLCDTextAfterCommit();
 
   EXPECT_FALSE(pending_layer_->RasterSourceUsesLCDText());
-  EXPECT_NE(pending_pile.get(), pending_layer_->raster_source());
+  EXPECT_NE(pending_raster_source.get(), pending_layer_->raster_source());
   EXPECT_TRUE(pending_layer_->HighResTiling()->has_tiles());
   tiles = pending_layer_->HighResTiling()->AllTilesForTesting();
   prioritized_tiles = pending_layer_->HighResTiling()
@@ -4959,9 +4809,9 @@ TEST_F(PictureLayerImplTest, TilingAllTilesDone) {
   gfx::Size layer_bounds(1000, 1000);
 
   // Create tiles.
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  SetupPendingTree(pending_raster_source);
   pending_layer_->SetBounds(layer_bounds);
   ActivateTree();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
@@ -5070,18 +4920,10 @@ TEST_F(TileSizeTest, TileSizes) {
 }
 
 TEST_F(NoLowResPictureLayerImplTest, LowResWasHighResCollision) {
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
-
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
-  // Set up the high and low res tilings before pinch zoom.
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
   ResetTilingsAndRasterScales();
 
   float page_scale = 2.f;
@@ -5100,18 +4942,11 @@ TEST_F(NoLowResPictureLayerImplTest, LowResWasHighResCollision) {
 }
 
 TEST_F(PictureLayerImplTest, HighResWasLowResCollision) {
-  gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-
-  // Set up the high and low res tilings before pinch zoom.
-  SetupTrees(pending_pile, active_pile);
+  SetupDefaultTrees(layer_bounds);
   ResetTilingsAndRasterScales();
 
   float page_scale = 4.f;