cc: Remove PicturePile and PicturePileImpl.

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
 
 #include "base/location.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/quads/draw_quad.h"
 #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"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/tiles/tiling_set_raster_queue_all.h"
 #include "cc/tiles/tiling_set_raster_queue_required.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 82 matching lines @@
 
   ~PictureLayerImplTest() override {}
 
   void SetUp() override { InitializeRenderer(); }
 
   virtual void InitializeRenderer() {
     host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
   }
 
   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<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);
-
-    SetupTreesWithInvalidation(pending_pile, active_pile, invalidation);
+    SetupTreesWithInvalidation(pending_raster_source, active_raster_source,
+                               invalidation);
   }
 
   void ActivateTree() {
     host_impl_.ActivateSyncTree();
     CHECK(!host_impl_.pending_tree());
     CHECK(host_impl_.recycle_tree());
     old_pending_layer_ = pending_layer_;
     pending_layer_ = nullptr;
     active_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.active_tree()->LayerById(id_));
 
     bool update_lcd_text = false;
     host_impl_.active_tree()->UpdateDrawProperties(update_lcd_text);
   }
 
   void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
                                           const gfx::Size& tile_size,
                                           const Region& invalidation) {
-    gfx::Size pile_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(pile_tile_size, layer_bounds);
-    scoped_refptr<FakePicturePileImpl> active_pile =
-        FakePicturePileImpl::CreateFilledPile(pile_tile_size, 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) {
     SetupPendingTreeInternal(raster_source, gfx::Size(), Region());
   }
 
   void SetupPendingTreeWithInvalidation(
       scoped_refptr<RasterSource> raster_source,
       const Region& invalidation) {
     SetupPendingTreeInternal(raster_source, gfx::Size(), invalidation);
@@ skipping 24 matching lines @@
       if (!tile_size.IsEmpty())
         pending_layer->set_fixed_tile_size(tile_size);
       pending_layer->SetDrawsContent(true);
     } else {
       pending_layer.reset(static_cast<FakePictureLayerImpl*>(
           pending_root->RemoveChild(pending_root->children()[0]).release()));
       if (!tile_size.IsEmpty())
         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);
 
     pending_root->AddChild(pending_layer.Pass());
     pending_tree->SetRootLayer(pending_root.Pass());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
 
     // Add tilings/tiles for the layer.
@@ skipping 18 matching lines @@
     DCHECK_EQ(layer->GetIdealContentsScale(), ideal_contents_scale);
     layer->draw_properties().maximum_animation_contents_scale =
         maximum_animation_contents_scale;
     layer->draw_properties().starting_animation_contents_scale =
         starting_animation_contents_scale;
     layer->draw_properties().screen_space_transform_is_animating =
         animating_transform_to_screen;
     bool resourceless_software_draw = false;
     layer->UpdateTiles(resourceless_software_draw);
   }
-  static void VerifyAllPrioritizedTilesExistAndHavePile(
+  static void VerifyAllPrioritizedTilesExistAndHaveRasterSource(
       const PictureLayerTiling* tiling,
-      PicturePileImpl* pile) {
+      RasterSource* raster_source) {
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
-      EXPECT_EQ(pile, prioritized_tiles[*iter].raster_source());
+      EXPECT_EQ(raster_source, prioritized_tiles[*iter].raster_source());
     }
   }
 
   void SetContentsScaleOnBothLayers(float contents_scale,
                                     float device_scale_factor,
                                     float page_scale_factor,
                                     float maximum_animation_contents_scale,
                                     float starting_animation_contents_scale,
                                     bool animating_transform) {
     SetupDrawPropertiesAndUpdateTiles(
@@ skipping 70 matching lines @@
   NoLowResPictureLayerImplTest()
       : PictureLayerImplTest(NoLowResTilingsSettings()) {}
 };
 
 TEST_F(PictureLayerImplTest, TileGridAlignment) {
   // Layer to span 4 raster tiles in x and in y
   LayerTreeSettings settings;
   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
     // at content scale 1.0, the playback canvas never receives content from
     // neighboring tiles which indicates that the tile grid embedded in
     // SkPicture is perfectly aligned with the compositor's tiles.
     EXPECT_EQ(1u, mock_canvas.rects_.size());
     EXPECT_EQ(*rect_iter, mock_canvas.rects_[0]);
     rect_iter++;
   }
 }
 
 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());
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i)
     EXPECT_TRUE(tilings->tiling_at(i)->AllTilesForTesting().empty());
 }
 
 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);
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
 
   // Update tiles with viewport for tile priority as (0, 0, 100, 100) and the
   // identify transform for tile priority.
   bool resourceless_software_draw = false;
   gfx::Rect viewport = gfx::Rect(layer_bounds),
@@ skipping 60 matching lines @@
     PictureLayerTiling* tiling = tilings->tiling_at(i);
     EXPECT_EQ(
         tiling->GetCurrentVisibleRectForTesting(),
         gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority_in_view_space,
                                   tiling->contents_scale()));
   }
 }
 
 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);
 
   // UpdateTiles with valid viewport. Should update tile viewport.
   // Note viewport is considered invalid if and only if in resourceless
   // software draw.
   bool resourceless_software_draw = false;
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   gfx::Transform transform;
@@ skipping 47 matching lines @@
                                         resourceless_software_draw);
   active_layer_->UpdateTiles(resourceless_software_draw);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform,
                                   active_layer_->screen_space_transform());
   EXPECT_EQ(viewport, active_layer_->visible_rect_for_tile_priority());
 }
 
 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);
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
 
   bool resourceless_software_draw = false;
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   gfx::Rect viewport_rect_for_tile_priority(0, 0, 100, 100);
   gfx::Transform transform, transform_for_tile_priority;
@@ skipping 20 matching lines @@
             active_layer_->viewport_rect_for_tile_priority_in_content_space());
   host_impl_.active_tree()->UpdateDrawProperties(update_lcd_text);
 
   // Now the UpdateDrawProperties is called. The viewport rect for tile
   // priority should be the latest value.
   EXPECT_EQ(another_viewport_rect_for_tile_priority,
             active_layer_->viewport_rect_for_tile_priority_in_content_space());
 }
 
 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);
   tiling->set_resolution(HIGH_RESOLUTION);
   tiling->CreateAllTilesForTesting();
 
   // Ensure UpdateTiles won't remove any tilings.
   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());
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect content_invalidation = gfx::ScaleToEnclosingRect(
         layer_invalidation,
         tiling->contents_scale());
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       // We don't always have a tile, but when we do it's because it was
       // invalidated and it has the latest raster source.
       if (*iter) {
         EXPECT_FALSE(iter.geometry_rect().IsEmpty());
-        EXPECT_EQ(pending_pile.get(), 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.
         EXPECT_FALSE(iter.geometry_rect().Intersects(content_invalidation));
       }
     }
   }
 
   tilings = active_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect content_invalidation =
         gfx::ScaleToEnclosingRect(layer_invalidation, tiling->contents_scale());
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
-      // Pile will be updated upon activation.
-      EXPECT_EQ(active_pile.get(), 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(),
             active_layer_->tilings()->num_tilings());
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
-  for (size_t i = 0; i < tilings->num_tilings(); ++i)
-    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);
 
   active_layer_->ReleaseResources();
   EXPECT_FALSE(active_layer_->tilings());
   active_layer_->RecreateResources();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 
   SetupDrawPropertiesAndUpdateTiles(active_layer_,
@@ skipping 47 matching lines @@
                                     0.f,    // starting animation scale
                                     false);
   ASSERT_EQ(6u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   active_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(7.26f * low_res_factor,
                   active_layer_->tilings()->tiling_at(3)->contents_scale());
 }
 
 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);
 
   pending_layer_->ReleaseResources();
   EXPECT_FALSE(pending_layer_->tilings());
   pending_layer_->RecreateResources();
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
@@ skipping 42 matching lines @@
                                     false);
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 }
 
 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());
 
   ActivateTree();
   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 =
       active_layer_->tilings()->FindTilingWithResolution(LOW_RESOLUTION);
   EXPECT_TRUE(low_res_tiling);
 
   ActivateTree();
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
   auto* other_low_res_tiling =
       active_layer_->tilings()->FindTilingWithResolution(LOW_RESOLUTION);
   EXPECT_TRUE(other_low_res_tiling);
   EXPECT_EQ(low_res_tiling, other_low_res_tiling);
 }
 
 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);
   EXPECT_EQ(32.f, active_layer_->HighResTiling()->contents_scale());
   host_impl_.PinchGestureBegin();
   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, 0.f, false);
   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, 0.f, false);
   EXPECT_EQ(active_layer_->tilings()->NumHighResTilings(), 1);
 }
 
 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);
   EXPECT_EQ(active_layer_->num_tilings(), 2u);
   EXPECT_EQ(pending_layer_->num_tilings(), 1u);
   EXPECT_EQ(active_layer_->tilings()->tiling_at(0)->contents_scale(), 2.f);
   EXPECT_EQ(active_layer_->tilings()->tiling_at(1)->contents_scale(),
             2.f * low_res_factor);
   // One of the tilings has to be a low resolution one.
   EXPECT_EQ(LOW_RESOLUTION,
@@ skipping 57 matching lines @@
                   active_layer_->tilings()->tiling_at(0)->contents_scale());
   // Now that we stopped pinching, the low resolution tiling that existed should
   // now be marked as low resolution.
   low_res_tiling =
       active_layer_->tilings()->FindTilingWithScale(4.f * low_res_factor);
   EXPECT_TRUE(low_res_tiling);
   EXPECT_EQ(LOW_RESOLUTION, low_res_tiling->resolution());
 }
 
 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());
 
   // Set up the high and low res tilings before pinch zoom.
   SetContentsScaleOnBothLayers(0.24f, 1.0f, 0.24f, 1.0f, 0.f, false);
   EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(0.24f,
                   active_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(0.0625f,
@@ skipping 31 matching lines @@
 
   // Zoom in a lot. Since we move in factors of two, we should get a scale that
   // is a power of 2 times 0.24.
   SetContentsScaleOnBothLayers(1.f, 1.0f, 1.f, 1.0f, 0.f, false);
   EXPECT_EQ(4u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(1.92f,
                   active_layer_->tilings()->tiling_at(0)->contents_scale());
 }
 
 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;
   EXPECT_LT(low_res_factor, 1.f);
 
   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());
 
   // Ensure UpdateTiles won't remove any tilings. Note this is unrelated to
   // |used_tilings| variable, and it's here only to ensure that active_layer_
   // won't remove tilings before the test has a chance to verify behavior.
   active_layer_->MarkAllTilingsUsed();
 
   // We only have ideal tilings, so they aren't removed.
   used_tilings.clear();
@@ skipping 146 matching lines @@
                                starting_animation_scale, animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
   EXPECT_EQ(active_layer_->LowResTiling()->contents_scale(),
             2.f * low_res_factor);
   EXPECT_EQ(4u, active_layer_->num_tilings());
   EXPECT_EQ(1u, pending_layer_->num_tilings());
 }
 
 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;
   float page_scale = 1.f;
   float maximum_animation_scale = 1.f;
   float starting_animation_scale = 0.f;
   bool animating_transform = false;
 
   // Contents exactly fit on one tile at scale 1, no low res.
   float contents_scale = 1.f;
@@ skipping 24 matching lines @@
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
   EXPECT_EQ(active_layer_->LowResTiling()->contents_scale(),
             contents_scale * low_res_factor);
   EXPECT_FALSE(pending_layer_->LowResTiling());
   EXPECT_EQ(active_layer_->num_tilings(), 2u);
   EXPECT_EQ(pending_layer_->num_tilings(), 1u);
 
   // 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);
 
   SetupDrawPropertiesAndUpdateTiles(
       mask.get(), contents_scale, device_scale, page_scale,
       maximum_animation_scale, starting_animation_scale, animating_transform);
   EXPECT_EQ(mask->HighResTiling()->contents_scale(), contents_scale);
   EXPECT_EQ(mask->num_tilings(), 1u);
 }
 
 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());
   pending_layer_->SetHasRenderSurface(true);
 
   host_impl_.pending_tree()->BuildPropertyTreesForTesting();
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
@@ skipping 28 matching lines @@
   SetupDrawPropertiesAndUpdateTiles(active_mask, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
   active_mask->HighResTiling()->CreateAllTilesForTesting();
   EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
   EXPECT_NE(0u, mask_resource_id);
   EXPECT_EQ(active_mask->bounds(), mask_texture_size);
 
   // 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);
 
   // The mask tiling gets scaled down.
   EXPECT_LT(pending_mask->HighResTiling()->contents_scale(), 1.f);
   EXPECT_EQ(1u, pending_mask->num_tilings());
 
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
       pending_mask->HighResTiling()->AllTilesForTesting());
@@ skipping 15 matching lines @@
   pending_mask->RecreateResources();
   active_mask->RecreateResources();
   SetupDrawPropertiesAndUpdateTiles(active_mask, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
   active_mask->HighResTiling()->CreateAllTilesForTesting();
   EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
   EXPECT_NE(0u, mask_resource_id);
   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);
   EXPECT_EQ(expected_size, mask_texture_size);
   EXPECT_EQ(0u, mask_resource_id);
 
   // Resize even larger, so that the scale would be smaller than the minimum
   // 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());
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   EXPECT_EQ(0u, pending_mask->num_tilings());
 }
 
 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());
   pending_layer_->SetHasRenderSurface(true);
 
   host_impl_.pending_tree()->BuildPropertyTreesForTesting();
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
@@ skipping 18 matching lines @@
   ResourceId mask_resource_id;
   gfx::Size mask_texture_size;
   active_mask->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_NE(0u, mask_resource_id);
   gfx::Size expected_mask_texture_size =
       gfx::ToCeiledSize(gfx::ScaleSize(active_mask->bounds(), 1.3f));
   EXPECT_EQ(mask_texture_size, expected_mask_texture_size);
 }
 
 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.
   active_layer_->ReleaseResources();
   EXPECT_FALSE(active_layer_->tilings());
   active_layer_->RecreateResources();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   pending_layer_->ReleaseResources();
   EXPECT_FALSE(pending_layer_->tilings());
   pending_layer_->RecreateResources();
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   // This should create new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
                                     1.f,  // ideal contents scale
                                     1.f,  // device scale
                                     1.f,  // page scale
                                     1.f,  // maximum animation scale
                                     0.f,  // starting animation_scale
                                     false);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
 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();
 
   // The default value.
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             host_impl_.settings().default_tile_size.ToString());
 
   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
@@ skipping 15 matching lines @@
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // Verify the tiles are not larger than the context's max texture size.
   tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_GE(140, tile->content_rect().width());
   EXPECT_GE(140, tile->content_rect().height());
 }
 
 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();
 
   // The default value. The layer is smaller than this.
   EXPECT_EQ(gfx::Size(512, 512).ToString(),
             host_impl_.settings().max_untiled_layer_size.ToString());
 
   // There should be a single tile since the layer is small.
   PictureLayerTiling* high_res_tiling = active_layer_->tilings()->tiling_at(0);
@@ skipping 22 matching lines @@
 
   // Verify the tiles are not larger than the context's max texture size.
   Tile* tile = active_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_GE(140, tile->content_rect().width());
   EXPECT_GE(140, tile->content_rect().height());
 }
 
 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);
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, nullptr);
   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);
   EXPECT_EQ(render_pass->quad_list.front()->opaque_rect, layer_rect);
   EXPECT_EQ(render_pass->quad_list.front()->visible_rect, layer_rect);
 }
 
 TEST_F(PictureLayerImplTest, ResourcelessPartialRecording) {
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(700, 650);
   gfx::Rect layer_rect(layer_bounds);
   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);
   gfx::Rect visible_rect(30, 35, 10, 5);
   active_layer_->draw_properties().visible_layer_rect = visible_rect;
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   gfx::Rect scaled_visible = gfx::ScaleToEnclosingRect(visible_rect, 2.f);
   gfx::Rect scaled_recorded = gfx::ScaleToEnclosingRect(recorded_viewport, 2.f);
   gfx::Rect quad_visible = gfx::IntersectRects(scaled_visible, scaled_recorded);
 
   ASSERT_EQ(1U, render_pass->quad_list.size());
   EXPECT_EQ(DrawQuad::PICTURE_CONTENT,
             render_pass->quad_list.front()->material);
   const DrawQuad* quad = render_pass->quad_list.front();
   EXPECT_EQ(quad_visible, quad->rect);
   EXPECT_EQ(quad_visible, quad->opaque_rect);
   EXPECT_EQ(quad_visible, quad->visible_rect);
 }
 
 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);
   active_layer_->draw_properties().visible_layer_rect = gfx::Rect(layer_bounds);
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   EXPECT_EQ(0U, render_pass->quad_list.size());
 }
 
 TEST_F(PictureLayerImplTest, SolidColorLayerHasVisibleFullCoverage) {
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size tile_size(1000, 1000);
   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<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFromPile(empty_recording.get(), nullptr);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFromPile(empty_recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          empty_recording.get(), false);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          empty_recording.get(), false);
 
-  SetupTrees(pending_pile, active_pile);
+  EXPECT_TRUE(pending_raster_source->IsSolidColor());
+  EXPECT_TRUE(active_raster_source->IsSolidColor());
+
+  SetupTrees(pending_raster_source, active_raster_source);
 
   active_layer_->draw_properties().visible_layer_rect = visible_rect;
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   Region remaining = visible_rect;
   for (const auto& quad : render_pass->quad_list) {
     EXPECT_TRUE(visible_rect.Contains(quad->rect));
     EXPECT_TRUE(remaining.Contains(quad->rect));
     remaining.Subtract(quad->rect);
   }
 
   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);
+  scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+  scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+      FakeDisplayListRasterSource::CreateFilledSolidColor(layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
-  // Solid color pile should not allow tilings at any scale.
+  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;
   gfx::Transform transform_for_tile_priority;
   bool resourceless_software_draw = false;
   gfx::Rect viewport(0, 0, 100, 200);
   host_impl_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         viewport,
                                         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());
 
   base::TimeTicks time_ticks;
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   pending_layer_->UpdateTiles(resourceless_software_draw);
 
   int num_visible = 0;
   int num_offscreen = 0;
@@ skipping 18 matching lines @@
 
 TEST_F(NoLowResPictureLayerImplTest,
        TileOutsideOfViewportForTilePriorityNotRequired) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   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());
 
   // Set external viewport for tile priority.
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   gfx::Transform transform;
   gfx::Transform transform_for_tile_priority;
   bool resourceless_software_draw = false;
   host_impl_.SetExternalDrawConstraints(transform,
@@ skipping 58 matching lines @@
   EXPECT_EQ(0u, data.num_incomplete_tiles);
   EXPECT_FALSE(active_layer_->only_used_low_res_last_append_quads());
 }
 
 TEST_F(PictureLayerImplTest, HighResTileIsComplete) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   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.
   std::vector<Tile*> tiles =
       active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
 
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   // All high res tiles drew, nothing was incomplete.
   EXPECT_EQ(9u, render_pass->quad_list.size());
   EXPECT_EQ(0u, data.num_missing_tiles);
   EXPECT_EQ(0u, data.num_incomplete_tiles);
   EXPECT_FALSE(active_layer_->only_used_low_res_last_append_quads());
 }
 
 TEST_F(PictureLayerImplTest, HighResTileIsIncomplete) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   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();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   EXPECT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(1u, data.num_missing_tiles);
   EXPECT_EQ(0u, data.num_incomplete_tiles);
   EXPECT_TRUE(active_layer_->only_used_low_res_last_append_quads());
 }
 
 TEST_F(PictureLayerImplTest, HighResTileIsIncompleteLowResComplete) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   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 =
       active_layer_->tilings()->tiling_at(1)->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(low_tiles);
 
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   EXPECT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(0u, data.num_missing_tiles);
   EXPECT_EQ(1u, data.num_incomplete_tiles);
   EXPECT_TRUE(active_layer_->only_used_low_res_last_append_quads());
 }
 
 TEST_F(PictureLayerImplTest, LowResTileIsIncomplete) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   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.
   std::vector<Tile*> high_tiles =
       active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
   high_tiles.erase(high_tiles.begin());
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(high_tiles);
 
   // All low res tiles have resources.
   std::vector<Tile*> low_tiles =
@@ skipping 17 matching lines @@
        HighResAndIdealResTileIsCompleteWhenRasterScaleIsNotIdeal) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
   gfx::Size viewport_size(400, 400);
 
   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;
   EXPECT_EQ(2.f, active_layer_->HighResTiling()->contents_scale());
   ideal_tiles.push_back(active_layer_->HighResTiling()->TileAt(0, 0));
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
       ideal_tiles);
 
   // Due to layer scale throttling, the raster contents scale is changed to 1,
   // while the ideal is still 2.
@@ skipping 121 matching lines @@
   active_layer_->LowResTiling()->UpdateAllRequiredStateForTesting();
 
   AssertNoTilesRequired(active_layer_->HighResTiling());
   AssertNoTilesRequired(active_layer_->LowResTiling());
 }
 
 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());
   EXPECT_EQ(active_layer_->tilings()->num_tilings(), 2u);
   EXPECT_EQ(active_layer_->HighResTiling()->AllTilesForTesting().size(), 0u);
 
   // Since the active layer has no tiles at all, the pending layer doesn't
   // need content in order to activate.
   pending_layer_->HighResTiling()->UpdateAllRequiredStateForTesting();
   EXPECT_FALSE(pending_layer_->LowResTiling());
 
   AssertNoTilesRequired(pending_layer_->HighResTiling());
 }
 
 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());
 
   // All high res tiles required.  This should be considered identical
   // to the case where there is no active layer, to avoid flashing content.
   // This can happen if a layer exists for a while and switches from
   // not being able to have content to having content.
   pending_layer_->HighResTiling()->UpdateAllRequiredStateForTesting();
   EXPECT_FALSE(pending_layer_->LowResTiling());
 
   AssertAllTilesRequired(pending_layer_->HighResTiling());
 }
 
 TEST_F(PictureLayerImplTest, HighResRequiredWhenActiveHasDifferentBounds) {
   gfx::Size pending_layer_bounds(400, 400);
   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.
   pending_layer_->HighResTiling()->UpdateAllRequiredStateForTesting();
   EXPECT_FALSE(pending_layer_->LowResTiling());
   active_layer_->HighResTiling()->UpdateAllRequiredStateForTesting();
   active_layer_->LowResTiling()->UpdateAllRequiredStateForTesting();
 
   AssertAllTilesRequired(pending_layer_->HighResTiling());
   AssertAllTilesRequired(active_layer_->HighResTiling());
   AssertNoTilesRequired(active_layer_->LowResTiling());
 }
 
 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());
 
   pending_layer_ = static_cast<FakePictureLayerImpl*>(
       host_impl_.pending_tree()->LayerById(id_));
 
   // Set some state on the pending layer, make sure it is not clobbered
   // by a sync from the active layer.  This could happen because if the
   // pending layer has not been post-commit initialized it will attempt
   // to sync from the active layer.
   float raster_page_scale = 10.f * pending_layer_->raster_page_scale();
   pending_layer_->set_raster_page_scale(raster_page_scale);
 
   host_impl_.ActivateSyncTree();
 
   active_layer_ = static_cast<FakePictureLayerImpl*>(
       host_impl_.active_tree()->LayerById(id_));
 
   EXPECT_EQ(0u, active_layer_->num_tilings());
   EXPECT_EQ(raster_page_scale, active_layer_->raster_page_scale());
 }
 
 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);
   first_invalidate.Inset(tiling->TilingDataForTesting().border_texels(),
                          tiling->TilingDataForTesting().border_texels());
   gfx::Rect second_invalidate = tiling->TilingDataForTesting().TileBounds(1, 1);
   second_invalidate.Inset(tiling->TilingDataForTesting().border_texels(),
                           tiling->TilingDataForTesting().border_texels());
 
   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));
   EXPECT_TRUE(active_tiling->TileAt(0, 1));
   EXPECT_FALSE(pending_tiling->TileAt(0, 0));
   EXPECT_FALSE(pending_tiling->TileAt(1, 0));
   EXPECT_FALSE(pending_tiling->TileAt(0, 1));
   EXPECT_NE(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
   EXPECT_TRUE(active_tiling->TileAt(1, 1));
   EXPECT_TRUE(pending_tiling->TileAt(1, 1));
@@ skipping 32 matching lines @@
   EXPECT_TRUE(active_tiling->TileAt(0, 1));
   EXPECT_TRUE(active_tiling->TileAt(1, 1));
 
   EXPECT_FALSE(pending_tiling->TileAt(0, 0));
   EXPECT_FALSE(pending_tiling->TileAt(1, 0));
   EXPECT_FALSE(pending_tiling->TileAt(0, 1));
   EXPECT_FALSE(pending_tiling->TileAt(1, 1));
 }
 
 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);
 
   // The active tree invalidation was handled by the active tiles.
   PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
   PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
   ASSERT_TRUE(active_tiling);
   ASSERT_TRUE(pending_tiling);
 
@@ skipping 31 matching lines @@
   EXPECT_FALSE(pending_tiling->TileAt(1, 0));
   EXPECT_FALSE(pending_tiling->TileAt(0, 1));
   EXPECT_FALSE(pending_tiling->TileAt(1, 1));
 
   EXPECT_NE(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
 }
 
 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));
 
   // Gpu rasterization is disabled by default.
   EXPECT_FALSE(host_impl_.use_gpu_rasterization());
   // Toggling the gpu rasterization clears all tilings on both trees.
   host_impl_.SetHasGpuRasterizationTrigger(true);
   host_impl_.SetContentIsSuitableForGpuRasterization(true);
   host_impl_.UpdateTreeResourcesForGpuRasterizationIfNeeded();
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 
   // Make sure that we can still add tiling to the pending layer,
   // that gets synced to the active layer.
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
   EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.f));
 
   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.
   EXPECT_TRUE(host_impl_.use_gpu_rasterization());
   host_impl_.SetHasGpuRasterizationTrigger(false);
   host_impl_.UpdateTreeResourcesForGpuRasterizationIfNeeded();
   EXPECT_EQ(GpuRasterizationStatus::OFF_VIEWPORT,
             host_impl_.gpu_rasterization_status());
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 
   host_impl_.SetHasGpuRasterizationTrigger(true);
   host_impl_.SetContentIsSuitableForGpuRasterization(false);
   EXPECT_EQ(GpuRasterizationStatus::OFF_CONTENT,
             host_impl_.gpu_rasterization_status());
 }
 
 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());
   EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(0.5f));
 
   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());
 
   // Since the MinContentsScale is 1, the 0.5 tiling should have been replaced
   // by a 1.0 tiling during the UDP in SetupPendingTree.
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
   PictureLayerTiling* tiling =
       pending_layer_->tilings()->FindTilingWithScale(1.0f);
   ASSERT_TRUE(tiling);
@@ skipping 392 matching lines @@
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
 }
 
 TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   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;
   bool reached_prepaint = false;
   int non_ideal_tile_count = 0u;
   int low_res_tile_count = 0u;
   int high_res_tile_count = 0u;
   int high_res_now_tiles = 0u;
   scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
@@ skipping 107 matching lines @@
   queue.reset(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), true));
   EXPECT_TRUE(queue->IsEmpty());
 }
 
 TEST_F(PictureLayerImplTest, TilingSetRasterQueueActiveTree) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   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());
 
   scoped_ptr<TilingSetRasterQueueRequired> queue(
       new TilingSetRasterQueueRequired(
           active_layer_->picture_layer_tiling_set(),
           RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
   EXPECT_FALSE(queue->IsEmpty());
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
     EXPECT_FALSE(prioritized_tile.tile()->draw_info().IsReadyToDraw());
     queue->Pop();
   }
 
   queue.reset(new TilingSetRasterQueueRequired(
       active_layer_->picture_layer_tiling_set(),
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
   EXPECT_TRUE(queue->IsEmpty());
 }
 
 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<FakeDisplayListRasterSource> pending_raster_source =
+      FakeDisplayListRasterSource::CreateFilledSolidColor(
+          gfx::Size(1024, 1024));
 
-  scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateFromPile(empty_recording.get(), nullptr);
-
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_raster_source);
   EXPECT_FALSE(
       pending_layer_->picture_layer_tiling_set()->FindTilingWithResolution(
           HIGH_RESOLUTION));
 
   scoped_ptr<TilingSetRasterQueueRequired> queue(
       new TilingSetRasterQueueRequired(
           pending_layer_->picture_layer_tiling_set(),
           RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
   EXPECT_TRUE(queue->IsEmpty());
 }
 
 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;
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
     all_tiles.insert(all_tiles.end(), tiles.begin(), tiles.end());
   }
 
   std::set<Tile*> all_tiles_set(all_tiles.begin(), all_tiles.end());
@@ skipping 119 matching lines @@
 }
 
 TEST_F(PictureLayerImplTest, Occlusion) {
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
   gfx::Size viewport_size(1000, 1000);
 
   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 =
       active_layer_->HighResTiling()->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
 
   {
     SCOPED_TRACE("No occlusion");
     gfx::Rect occluded;
     impl.AppendQuadsWithOcclusion(active_layer_, occluded);
@@ skipping 120 matching lines @@
 
   // The pending high-res tiles are not ready, so we cannot activate.
   EXPECT_FALSE(host_impl_.tile_manager()->IsReadyToActivate());
 
   // When the pending high-res tiles are ready, we can activate.
   pending_layer_->SetAllTilesReadyInTiling(pending_layer_->HighResTiling());
   EXPECT_TRUE(host_impl_.tile_manager()->IsReadyToActivate());
 }
 
 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);
 
   ResetTilingsAndRasterScales();
 
   SetupDrawPropertiesAndUpdateTiles(active_layer_,
                                     6.f,  // ideal contents scale
                                     3.f,  // device scale
                                     2.f,  // page scale
@@ skipping 36 matching lines @@
                                     3.3f,   // page scale
                                     1.f,    // maximum animation scale
                                     0.f,    // starting animation scale
                                     false);
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   active_layer_->tilings()->tiling_at(0)->contents_scale());
 }
 
 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);
 
   ResetTilingsAndRasterScales();
 
   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
                                     6.f,  // ideal contents scale
                                     3.f,  // device scale
                                     2.f,  // page scale
@@ skipping 63 matching lines @@
 
   AssertAllTilesRequired(active_layer_->HighResTiling());
   if (host_impl_.settings().create_low_res_tiling)
     AssertNoTilesRequired(active_layer_->LowResTiling());
 }
 
 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());
   EXPECT_EQ(active_layer_->tilings()->num_tilings(),
             host_impl_.settings().create_low_res_tiling ? 2u : 1u);
   EXPECT_EQ(active_layer_->HighResTiling()->AllTilesForTesting().size(), 0u);
 
   // Since the active layer has no tiles at all, the pending layer doesn't
   // need content in order to activate.
   pending_layer_->HighResTiling()->UpdateAllRequiredStateForTesting();
   if (host_impl_.settings().create_low_res_tiling)
     pending_layer_->LowResTiling()->UpdateAllRequiredStateForTesting();
 
   AssertNoTilesRequired(pending_layer_->HighResTiling());
   if (host_impl_.settings().create_low_res_tiling)
     AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
 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);
 
   // UpdateTiles with valid viewport. Should update tile viewport.
   // Note viewport is considered invalid if and only if in resourceless
   // software draw.
   bool resourceless_software_draw = false;
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   gfx::Transform transform;
@@ skipping 46 matching lines @@
                                         transform,
                                         resourceless_software_draw);
   active_layer_->UpdateTiles(resourceless_software_draw);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform,
                                   active_layer_->screen_space_transform());
   EXPECT_EQ(viewport, active_layer_->visible_rect_for_tile_priority());
 }
 
 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);
 
   float device_scale = 1.7f;
   float page_scale = 3.2f;
   float scale = 1.f;
 
   ResetTilingsAndRasterScales();
 
@@ skipping 86 matching lines @@
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 
   // If we remove it from our used tilings set, it is outside the range to keep
   // so it is deleted.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
 }
 
 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());
 
   // All tilings should be removed when losing output surface.
   active_layer_->ReleaseResources();
   EXPECT_FALSE(active_layer_->tilings());
   active_layer_->RecreateResources();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   pending_layer_->ReleaseResources();
   EXPECT_FALSE(pending_layer_->tilings());
   pending_layer_->RecreateResources();
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   // This should create new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
                                     1.3f,  // ideal contents scale
                                     2.7f,  // device scale
                                     3.2f,  // page scale
                                     1.f,   // maximum animation scale
                                     0.f,   // starting animation scale
                                     false);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
 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,
                                     false);
 
   float max_contents_scale = active_layer_->MaximumTilingContentsScale();
   EXPECT_EQ(2.5f, max_contents_scale);
 
   gfx::Transform scaled_draw_transform = active_layer_->draw_transform();
   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
@@ skipping 27 matching lines @@
 
   void InitializeRenderer() override {
     host_impl_.InitializeRenderer(FakeOutputSurface::CreateDelegating3d());
   }
 };
 
 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;
   host_impl_.active_tree()->UpdateDrawProperties(update_lcd_text);
   std::vector<Tile*> tiles =
       active_layer_->HighResTiling()->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
 
   // Force tiles after max_tiles to be OOM. TileManager uses
   // GlobalStateThatImpactsTilesPriority from LayerTreeHostImpl, and we cannot
   // directly set state to host_impl_, so we set policy that would change the
   // 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,
                              gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
                              resource_limit);
   host_impl_.SetMemoryPolicy(policy);
   host_impl_.SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   host_impl_.PrepareTiles();
 
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
@@ skipping 69 matching lines @@
        OccludedTilesSkippedDuringRasterization) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
   gfx::Size viewport_size(500, 500);
   gfx::Point occluding_layer_position(310, 0);
 
   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;
   scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     Tile* tile = prioritized_tile.tile();
 
     // Occluded tiles should not be iterated over.
@@ skipping 66 matching lines @@
        OccludedTilesNotMarkedAsRequired) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
   gfx::Size viewport_size(500, 500);
   gfx::Point occluding_layer_position(310, 0);
 
   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;
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
     occluded_tile_count = 0;
     for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f,
@@ skipping 92 matching lines @@
 }
 
 TEST_F(OcclusionTrackingPictureLayerImplTest, OcclusionForDifferentScales) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
   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));
   LayerImpl* layer1 = pending_layer_->children()[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
   layer1->SetPosition(occluding_layer_position);
 
   pending_layer_->tilings()->RemoveAllTilings();
@@ skipping 48 matching lines @@
   }
 }
 
 TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
   gfx::Size viewport_size(1000, 1000);
   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));
   LayerImpl* layer1 = pending_layer_->children()[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
   layer1->SetPosition(occluding_layer_position);
 
   ActivateTree();
@@ skipping 13 matching lines @@
       gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
           tile->content_rect(), 1.0f / tile->contents_scale());
       // Tiles are occluded on the active tree iff they lie beneath the
       // occluding layer.
       EXPECT_EQ(prioritized_tiles[tile].is_occluded(),
                 scaled_content_rect.x() >= occluding_layer_position.x());
     }
   }
 
   // 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);
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
     for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f,
                                                    gfx::Rect(layer_bounds));
          iter; ++iter) {
       if (!*iter)
@@ skipping 33 matching lines @@
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
   gfx::Size viewport_size(1000, 1000);
   gfx::Point pending_occluding_layer_position(310, 0);
   gfx::Point active_occluding_layer_position(0, 310);
   gfx::Rect invalidation_rect(230, 230, 152, 152);
 
   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));
   LayerImpl* active_occluding_layer = pending_layer_->children()[0];
   active_occluding_layer->SetBounds(layer_bounds);
   active_occluding_layer->SetDrawsContent(true);
   active_occluding_layer->SetContentsOpaque(true);
   active_occluding_layer->SetPosition(active_occluding_layer_position);
 
   ActivateTree();
 
   // 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));
   LayerImpl* pending_occluding_layer = pending_layer_->children()[0];
   pending_occluding_layer->SetBounds(layer_bounds);
   pending_occluding_layer->SetDrawsContent(true);
   pending_occluding_layer->SetContentsOpaque(true);
   pending_occluding_layer->SetPosition(pending_occluding_layer_position);
 
   EXPECT_EQ(1u, pending_layer_->num_tilings());
@@ skipping 95 matching lines @@
   VerifyEvictionConsidersOcclusion(
       active_layer_, ACTIVE_TREE,
       total_expected_occluded_tile_count_on_trees[ACTIVE_TREE], __LINE__);
   VerifyEvictionConsidersOcclusion(
       pending_layer_, PENDING_TREE,
       total_expected_occluded_tile_count_on_trees[PENDING_TREE], __LINE__);
   pending_layer_->set_has_valid_tile_priorities(true);
 }
 
 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());
   EXPECT_EQ(active_layer_, pending_layer_->GetPendingOrActiveTwinLayer());
 
   ActivateTree();
   EXPECT_FALSE(active_layer_->GetPendingOrActiveTwinLayer());
 
   // Make an empty pending tree.
   host_impl_.CreatePendingTree();
@@ skipping 116 matching lines @@
   ActivateTree();
 
   // We've switched to a solid color, so we should end up with no tilings.
   ASSERT_TRUE(active_layer_->tilings());
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 }
 
 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);
   gfx::Transform transform;
 
   host_impl_.SetRequiresHighResToDraw();
 
   // Update tiles.
   pending_layer_->draw_properties().visible_layer_rect = viewport;
   pending_layer_->draw_properties().screen_space_transform = transform;
@@ skipping 37 matching lines @@
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
 
   // Ensure we can activate.
   EXPECT_TRUE(host_impl_.tile_manager()->IsReadyToActivate());
 }
 
 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();
   PictureLayerTiling* active_tiling = active_layer_->HighResTiling();
 
   // We should have all tiles on active, and none on pending.
   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));
   EXPECT_FALSE(pending_tiling->TileAt(1, 1));
   EXPECT_TRUE(pending_tiling->TileAt(2, 2));
 
   // Active is not affected yet.
   EXPECT_EQ(5u * 5u, active_tiling->AllTilesForTesting().size());
 
   // Activate the tree. The same tiles go missing on the active tree.
   ActivateTree();
   EXPECT_EQ(3u * 3u, active_tiling->AllTilesForTesting().size());
   EXPECT_FALSE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(active_tiling->TileAt(1, 1));
   EXPECT_TRUE(active_tiling->TileAt(2, 2));
 
   // 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);
   Tile* tile11 = pending_tiling->TileAt(1, 1);
   Tile* tile22 = pending_tiling->TileAt(2, 2);
 
   // Active is not affected yet.
   EXPECT_EQ(3u * 3u, active_tiling->AllTilesForTesting().size());
 
   // Activate the tree. The tiles are moved to the active tree.
   ActivateTree();
   EXPECT_EQ(5u * 5u, active_tiling->AllTilesForTesting().size());
   EXPECT_EQ(tile00, active_tiling->TileAt(0, 0));
   EXPECT_EQ(tile11, active_tiling->TileAt(1, 1));
   EXPECT_EQ(tile22, active_tiling->TileAt(2, 2));
 }
 
 TEST_F(PictureLayerImplTest, ScrollPastLiveTilesRectAndBack) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(100, 100);
   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);
+  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());
 
   host_impl_.SetExternalDrawConstraints(
       gfx::Transform(),              // transform
       gfx::Rect(),                   // clip
       gfx::Rect(),                   // viewport
       gfx::Rect(0, 5000, 100, 100),  // viewport_rect_for_tile_priority
       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());
   ActivateTree();
   EXPECT_FALSE(active_layer_->HighResTiling()->has_tiles());
   EXPECT_TRUE(active_layer_->HighResTiling()->live_tiles_rect().IsEmpty());
 
   host_impl_.SetExternalDrawConstraints(
       gfx::Transform(),             // transform
       gfx::Rect(),                  // clip
       gfx::Rect(),                  // viewport
       gfx::Rect(0, 110, 100, 100),  // viewport_rect_for_tile_priority
       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());
   ActivateTree();
   EXPECT_TRUE(active_layer_->HighResTiling()->has_tiles());
   EXPECT_FALSE(active_layer_->HighResTiling()->live_tiles_rect().IsEmpty());
 }
 
 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);
   EXPECT_EQ("0,50 100x100", active_layer_->HighResTiling()
                                 ->GetCurrentVisibleRectForTesting()
                                 .ToString());
 
   EXPECT_EQ("0,0 100x100", pending_layer_->HighResTiling()
                                ->GetCurrentVisibleRectForTesting()
                                .ToString());
   host_impl_.pending_tree()->UpdateDrawProperties(false);
   EXPECT_EQ("0,50 100x100", pending_layer_->HighResTiling()
                                 ->GetCurrentVisibleRectForTesting()
                                 .ToString());
 }
 
 TEST_F(PictureLayerImplTest, UpdateLCDInvalidatesPendingTree) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(100, 100);
   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);
-  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());
   std::vector<Tile*> tiles =
       pending_layer_->HighResTiling()->AllTilesForTesting();
   auto prioritized_tiles = pending_layer_->HighResTiling()
                                ->UpdateAndGetAllPrioritizedTilesForTesting();
 
   for (Tile* tile : tiles)
     EXPECT_EQ(pending_layer_->raster_source(),
               prioritized_tiles[tile].raster_source());
 
   pending_layer_->draw_properties().can_use_lcd_text = false;
   pending_layer_->UpdateCanUseLCDTextAfterCommit();
 
   EXPECT_FALSE(pending_layer_->RasterSourceUsesLCDText());
-  EXPECT_NE(pending_pile.get(), pending_layer_->raster_source());
+  EXPECT_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()
                           ->UpdateAndGetAllPrioritizedTilesForTesting();
   for (Tile* tile : tiles)
     EXPECT_EQ(pending_layer_->raster_source(),
               prioritized_tiles[tile].raster_source());
 }
 
 TEST_F(PictureLayerImplTest, TilingAllTilesDone) {
   gfx::Size tile_size = host_impl_.settings().default_tile_size;
   size_t tile_mem = 4 * tile_size.width() * tile_size.height();
   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(
       active_layer_->HighResTiling()->AllTilesForTesting());
   host_impl_.SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
 
   EXPECT_FALSE(active_layer_->HighResTiling()->all_tiles_done());
 
   {
     // Set a memory policy that will fit all tiles.
@@ skipping 88 matching lines @@
   // 50% of viewport in height.
   result = layer->CalculateTileSize(gfx::Size(447, 400));
   EXPECT_EQ(result.width(), 448);
   EXPECT_EQ(result.height(), 448);
   result = layer->CalculateTileSize(gfx::Size(500, 499));
   EXPECT_EQ(result.width(), 512);
   EXPECT_EQ(result.height(), 500 + 2);
 }
 
 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;
   SetContentsScaleOnBothLayers(page_scale, 1.0f, page_scale, 1.0f, 0.f, false);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
   EXPECT_BOTH_EQ(tilings()->tiling_at(0)->contents_scale(), page_scale);
 
   host_impl_.PinchGestureBegin();
 
   // Zoom out to exactly the low res factor so that the previous high res
   // would be equal to the current low res (if it were possible to have one).
   float zoomed = page_scale / low_res_factor;
   SetContentsScaleOnBothLayers(zoomed, 1.0f, zoomed, 1.0f, 0.f, false);
   EXPECT_EQ(1u, pending_layer_->num_tilings());
   EXPECT_EQ(zoomed, pending_layer_->tilings()->tiling_at(0)->contents_scale());
 }
 
 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;
   float low_res = page_scale * low_res_factor;
   float extra_low_res = low_res * low_res_factor;
   SetupDrawPropertiesAndUpdateTiles(active_layer_, page_scale, 1.0f, page_scale,
                                     1.0f, 0.f, false);
   EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
   EXPECT_EQ(page_scale,
             active_layer_->tilings()->tiling_at(0)->contents_scale());
@@ skipping 38 matching lines @@
   // New low res tiling.
   EXPECT_TRUE(tilings->tiling_at(2)->may_contain_low_resolution_tiles());
 
   // This tiling will be high res now, it won't contain low res content since it
   // was all destroyed.
   EXPECT_FALSE(tilings->tiling_at(1)->may_contain_low_resolution_tiles());
 }
 
 }  // namespace
 }  // namespace cc