cc: Remove PicturePile and PicturePileImpl.

cc/output/renderer_pixeltest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/message_loop/message_loop.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/video_resource_updater.h"
-#include "cc/test/fake_picture_pile_impl.h"
+#include "cc/test/fake_display_list_raster_source.h"
+#include "cc/test/fake_display_list_recording_source.h"
 #include "cc/test/pixel_test.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "media/base/video_frame.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h"
 #include "third_party/skia/include/effects/SkColorMatrixFilter.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ skipping 734 matching lines @@
                        this->quad_rect_.width() / 2,
                        this->quad_rect_.height() / 2);
 
   SkPaint black_paint;
   black_paint.setColor(SK_ColorBLACK);
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   SkPaint green_paint;
   green_paint.setColor(SK_ColorGREEN);
 
-  scoped_ptr<FakePicturePile> blue_recording =
-      FakePicturePile::CreateFilledPile(gfx::Size(1000, 1000),
-                                        this->quad_rect_.size());
+  scoped_ptr<FakeDisplayListRecordingSource> blue_recording =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+          this->quad_rect_.size());
   blue_recording->add_draw_rect_with_paint(outer_rect, black_paint);
   blue_recording->add_draw_rect_with_paint(inner_rect, blue_paint);
   blue_recording->Rerecord();
-  scoped_refptr<FakePicturePileImpl> blue_pile =
-      FakePicturePileImpl::CreateFromPile(blue_recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> blue_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          blue_recording.get(), false);
 
   PictureDrawQuad* blue_quad =
       this->render_pass_->template CreateAndAppendDrawQuad<PictureDrawQuad>();
 
   blue_quad->SetNew(this->front_quad_state_, this->quad_rect_, gfx::Rect(),
                     this->quad_rect_, gfx::RectF(this->quad_rect_),
                     this->quad_rect_.size(), false, RGBA_8888, this->quad_rect_,
-                    1.f, blue_pile);
+                    1.f, blue_raster_source);
 
-  scoped_ptr<FakePicturePile> green_recording =
-      FakePicturePile::CreateFilledPile(this->quad_rect_.size(),
-                                        this->quad_rect_.size());
+  scoped_ptr<FakeDisplayListRecordingSource> green_recording =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+          this->quad_rect_.size());
   green_recording->add_draw_rect_with_paint(outer_rect, green_paint);
   green_recording->add_draw_rect_with_paint(inner_rect, black_paint);
   green_recording->Rerecord();
-  scoped_refptr<FakePicturePileImpl> green_pile =
-      FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> green_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          green_recording.get(), false);
 
   PictureDrawQuad* green_quad =
       this->render_pass_->template CreateAndAppendDrawQuad<PictureDrawQuad>();
   green_quad->SetNew(this->back_quad_state_, this->quad_rect_, gfx::Rect(),
                      this->quad_rect_, gfx::RectF(this->quad_rect_),
                      this->quad_rect_.size(), false, RGBA_8888,
-                     this->quad_rect_, 1.f, green_pile);
+                     this->quad_rect_, 1.f, green_raster_source);
   SCOPED_TRACE("IntersectingPictureQuadsPass");
   this->template AppendBackgroundAndRunTest<PictureDrawQuad>(
       FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f));
 }
 
 TYPED_TEST(IntersectingQuadPixelTest, RenderPassQuads) {
   this->SetupQuadStateAndRenderPass();
   RenderPassId child_pass_id1(2, 2);
   RenderPassId child_pass_id2(2, 3);
   scoped_ptr<RenderPass> child_pass1 =
@@ skipping 1356 matching lines @@
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("anti_aliasing_perspective.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadIdentityScale) {
-  gfx::Size pile_tile_size(1000, 1000);
   gfx::Rect viewport(this->device_viewport_size_);
   // TODO(enne): the renderer should figure this out on its own.
   ResourceFormat texture_format = RGBA_8888;
   bool nearest_neighbor = false;
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
   // One clipped blue quad in the lower right corner.  Outside the clip
   // is red, which should not appear.
   gfx::Rect blue_rect(gfx::Size(100, 100));
   gfx::Rect blue_clip_rect(gfx::Point(50, 50), gfx::Size(50, 50));
 
-  scoped_ptr<FakePicturePile> blue_recording =
-      FakePicturePile::CreateFilledPile(pile_tile_size, blue_rect.size());
+  scoped_ptr<FakeDisplayListRecordingSource> blue_recording =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+          blue_rect.size());
   SkPaint red_paint;
   red_paint.setColor(SK_ColorRED);
   blue_recording->add_draw_rect_with_paint(blue_rect, red_paint);
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   blue_recording->add_draw_rect_with_paint(blue_clip_rect, blue_paint);
   blue_recording->Rerecord();
 
-  scoped_refptr<FakePicturePileImpl> blue_pile =
-      FakePicturePileImpl::CreateFromPile(blue_recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> blue_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          blue_recording.get(), false);
 
   gfx::Vector2d offset(viewport.bottom_right() - blue_rect.bottom_right());
   gfx::Transform blue_quad_to_target_transform;
   blue_quad_to_target_transform.Translate(offset.x(), offset.y());
   gfx::Rect blue_target_clip_rect = MathUtil::MapEnclosingClippedRect(
       blue_quad_to_target_transform, blue_clip_rect);
   SharedQuadState* blue_shared_state =
       CreateTestSharedQuadStateClipped(blue_quad_to_target_transform, blue_rect,
                                        blue_target_clip_rect, pass.get());
 
   PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
 
   blue_quad->SetNew(blue_shared_state,
                     viewport,  // Intentionally bigger than clip.
                     gfx::Rect(), viewport, gfx::RectF(viewport),
                     viewport.size(), nearest_neighbor, texture_format, viewport,
-                    1.f, blue_pile.get());
+                    1.f, blue_raster_source.get());

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

nit: no get()?

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

Changed to Pass.

 
   // One viewport-filling green quad.
-  scoped_ptr<FakePicturePile> green_recording =
-      FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
+  scoped_ptr<FakeDisplayListRecordingSource> green_recording =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+          viewport.size());
   SkPaint green_paint;
   green_paint.setColor(SK_ColorGREEN);
   green_recording->add_draw_rect_with_paint(viewport, green_paint);
   green_recording->Rerecord();
-  scoped_refptr<FakePicturePileImpl> green_pile =
-      FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> green_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          green_recording.get(), false);
 
   gfx::Transform green_quad_to_target_transform;
   SharedQuadState* green_shared_state = CreateTestSharedQuadState(
       green_quad_to_target_transform, viewport, pass.get());
 
   PictureDrawQuad* green_quad =
       pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   green_quad->SetNew(green_shared_state, viewport, gfx::Rect(), viewport,
                      gfx::RectF(0.f, 0.f, 1.f, 1.f), viewport.size(),
                      nearest_neighbor, texture_format, viewport, 1.f,
-                     green_pile.get());
+                     green_raster_source.get());

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

dittos

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

Changed to Pass.

 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")),
       ExactPixelComparator(true)));
 }
 
 // Not WithSkiaGPUBackend since that path currently requires tiles for opacity.
 TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadOpacity) {
-  gfx::Size pile_tile_size(1000, 1000);
   gfx::Rect viewport(this->device_viewport_size_);
   ResourceFormat texture_format = RGBA_8888;
   bool nearest_neighbor = false;
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
   // One viewport-filling 0.5-opacity green quad.
-  scoped_ptr<FakePicturePile> green_recording =
-      FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
+  scoped_ptr<FakeDisplayListRecordingSource> green_recording =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+          viewport.size());
   SkPaint green_paint;
   green_paint.setColor(SK_ColorGREEN);
   green_recording->add_draw_rect_with_paint(viewport, green_paint);
   green_recording->Rerecord();
-  scoped_refptr<FakePicturePileImpl> green_pile =
-      FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> green_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          green_recording.get(), false);
 
   gfx::Transform green_quad_to_target_transform;
   SharedQuadState* green_shared_state = CreateTestSharedQuadState(
       green_quad_to_target_transform, viewport, pass.get());
   green_shared_state->opacity = 0.5f;
 
   PictureDrawQuad* green_quad =
       pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   green_quad->SetNew(green_shared_state, viewport, gfx::Rect(), viewport,
                      gfx::RectF(0, 0, 1, 1), viewport.size(), nearest_neighbor,
-                     texture_format, viewport, 1.f, green_pile.get());
+                     texture_format, viewport, 1.f, green_raster_source.get());
 
   // One viewport-filling white quad.
-  scoped_ptr<FakePicturePile> white_recording =
-      FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
+  scoped_ptr<FakeDisplayListRecordingSource> white_recording =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+          viewport.size());
   SkPaint white_paint;
   white_paint.setColor(SK_ColorWHITE);
   white_recording->add_draw_rect_with_paint(viewport, white_paint);
   white_recording->Rerecord();
-  scoped_refptr<FakePicturePileImpl> white_pile =
-      FakePicturePileImpl::CreateFromPile(white_recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> white_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          white_recording.get(), false);
 
   gfx::Transform white_quad_to_target_transform;
   SharedQuadState* white_shared_state = CreateTestSharedQuadState(
       white_quad_to_target_transform, viewport, pass.get());
 
   PictureDrawQuad* white_quad =
       pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   white_quad->SetNew(white_shared_state, viewport, gfx::Rect(), viewport,
                      gfx::RectF(0, 0, 1, 1), viewport.size(), nearest_neighbor,
-                     texture_format, viewport, 1.f, white_pile.get());
+                     texture_format, viewport, 1.f, white_raster_source.get());

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

dittos 

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

Changed to Pass.

 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("green_alpha.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
@@ skipping 12 matching lines @@
 }
 
 // If we disable image filtering, then a 2x2 bitmap should appear as four
 // huge sharp squares.
 TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadDisableImageFiltering) {
   // We only care about this in software mode since bilinear filtering is
   // cheap in hardware.
   if (!IsSoftwareRenderer<TypeParam>())
     return;
 
-  gfx::Size pile_tile_size(1000, 1000);
   gfx::Rect viewport(this->device_viewport_size_);
   ResourceFormat texture_format = RGBA_8888;
   bool nearest_neighbor = false;
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
   skia::RefPtr<SkSurface> surface =
       skia::AdoptRef(SkSurface::NewRasterN32Premul(2, 2));
   ASSERT_NE(surface, nullptr);
   SkCanvas* canvas = surface->getCanvas();
   canvas->drawPoint(0, 0, SK_ColorGREEN);
   canvas->drawPoint(0, 1, SK_ColorBLUE);
   canvas->drawPoint(1, 0, SK_ColorBLUE);
   canvas->drawPoint(1, 1, SK_ColorGREEN);
   skia::RefPtr<SkImage> image = skia::AdoptRef(surface->newImageSnapshot());
 
-  scoped_ptr<FakePicturePile> recording =
-      FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
+  scoped_ptr<FakeDisplayListRecordingSource> recording =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+          viewport.size());
   SkPaint paint;
   paint.setFilterQuality(kLow_SkFilterQuality);
   recording->add_draw_image_with_paint(image.get(), gfx::Point(), paint);
   recording->Rerecord();
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFromPile(recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(recording.get(),
+                                                             false);
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   PictureDrawQuad* quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport,
                gfx::RectF(0, 0, 2, 2), viewport.size(), nearest_neighbor,
-               texture_format, viewport, 1.f, pile.get());
+               texture_format, viewport, 1.f, raster_source.get());

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

more dittos..

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

Changed to Pass.

 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   this->disable_picture_quad_image_filtering_ = true;
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
       ExactPixelComparator(true)));
 }
 
 // This disables filtering by setting |nearest_neighbor| on the PictureDrawQuad.
 TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNearestNeighbor) {
-  gfx::Size pile_tile_size(1000, 1000);
   gfx::Rect viewport(this->device_viewport_size_);
   ResourceFormat texture_format = RGBA_8888;
   bool nearest_neighbor = true;
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
   skia::RefPtr<SkSurface> surface =
       skia::AdoptRef(SkSurface::NewRasterN32Premul(2, 2));
   ASSERT_NE(surface, nullptr);
   SkCanvas* canvas = surface->getCanvas();
   canvas->drawPoint(0, 0, SK_ColorGREEN);
   canvas->drawPoint(0, 1, SK_ColorBLUE);
   canvas->drawPoint(1, 0, SK_ColorBLUE);
   canvas->drawPoint(1, 1, SK_ColorGREEN);
   skia::RefPtr<SkImage> image = skia::AdoptRef(surface->newImageSnapshot());
 
-  scoped_ptr<FakePicturePile> recording =
-      FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
+  scoped_ptr<FakeDisplayListRecordingSource> recording =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+          viewport.size());
   SkPaint paint;
   paint.setFilterQuality(kLow_SkFilterQuality);
   recording->add_draw_image_with_paint(image.get(), gfx::Point(), paint);
   recording->Rerecord();
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFromPile(recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(recording.get(),
+                                                             false);
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   PictureDrawQuad* quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport,
                gfx::RectF(0, 0, 2, 2), viewport.size(), nearest_neighbor,
-               texture_format, viewport, 1.f, pile.get());
+               texture_format, viewport, 1.f, raster_source.get());

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

D:

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

Changed to Pass.

 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
       ExactPixelComparator(true)));
 }
 
@@ skipping 148 matching lines @@
 
   // Allow for a small amount of error as the blending alogrithm used by Skia is
   // affected by the offset in the expanded rect.
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers_linear.png")),
       FuzzyPixelComparator(false, 100.f, 0.f, 16.f, 16.f, 0.f)));
 }
 
 TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {
-  gfx::Size pile_tile_size(1000, 1000);
   gfx::Rect viewport(this->device_viewport_size_);
   // TODO(enne): the renderer should figure this out on its own.
   ResourceFormat texture_format = RGBA_8888;
   bool nearest_neighbor = false;
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
   // As scaling up the blue checkerboards will cause sampling on the GPU,
   // a few extra "cleanup rects" need to be added to clobber the blending
   // to make the output image more clean.  This will also test subrects
   // of the layer.
   gfx::Transform green_quad_to_target_transform;
   gfx::Rect green_rect1(gfx::Point(80, 0), gfx::Size(20, 100));
   gfx::Rect green_rect2(gfx::Point(0, 80), gfx::Size(100, 20));
 
-  scoped_ptr<FakePicturePile> green_recording =
-      FakePicturePile::CreateFilledPile(pile_tile_size, viewport.size());
+  scoped_ptr<FakeDisplayListRecordingSource> green_recording =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+          viewport.size());
 
   SkPaint red_paint;
   red_paint.setColor(SK_ColorRED);
   green_recording->add_draw_rect_with_paint(viewport, red_paint);
   SkPaint green_paint;
   green_paint.setColor(SK_ColorGREEN);
   green_recording->add_draw_rect_with_paint(green_rect1, green_paint);
   green_recording->add_draw_rect_with_paint(green_rect2, green_paint);
   green_recording->Rerecord();
-  scoped_refptr<FakePicturePileImpl> green_pile =
-      FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> green_raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(
+          green_recording.get(), false);
 
   SharedQuadState* top_right_green_shared_quad_state =
       CreateTestSharedQuadState(green_quad_to_target_transform, viewport,
                                 pass.get());
 
   PictureDrawQuad* green_quad1 =
       pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   green_quad1->SetNew(top_right_green_shared_quad_state, green_rect1,
                       gfx::Rect(), green_rect1, gfx::RectF(green_rect1.size()),
                       green_rect1.size(), nearest_neighbor, texture_format,
-                      green_rect1, 1.f, green_pile.get());
+                      green_rect1, 1.f, green_raster_source.get());

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

...

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

Removed .get()

 
   PictureDrawQuad* green_quad2 =
       pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   green_quad2->SetNew(top_right_green_shared_quad_state, green_rect2,
                       gfx::Rect(), green_rect2, gfx::RectF(green_rect2.size()),
                       green_rect2.size(), nearest_neighbor, texture_format,
-                      green_rect2, 1.f, green_pile.get());
+                      green_rect2, 1.f, green_raster_source.get());

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

silly turn refptr into raw pointer into refptr..

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

Changed to Pass.

 
   // Add a green clipped checkerboard in the bottom right to help test
   // interleaving picture quad content and solid color content.
   gfx::Rect bottom_right_rect(
       gfx::Point(viewport.width() / 2, viewport.height() / 2),
       gfx::Size(viewport.width() / 2, viewport.height() / 2));
   SharedQuadState* bottom_right_green_shared_state =
       CreateTestSharedQuadStateClipped(green_quad_to_target_transform, viewport,
                                        bottom_right_rect, pass.get());
   SolidColorDrawQuad* bottom_right_color_quad =
@@ skipping 14 matching lines @@
   gfx::RectF blue_layer_rect2(gfx::PointF(8.0f, 6.5f), gfx::SizeF(2.5f, 2.5f));
   gfx::RectF union_layer_rect = blue_layer_rect1;
   union_layer_rect.Union(blue_layer_rect2);
 
   // Because scaling up will cause sampling outside the rects, add one extra
   // pixel of buffer at the final content scale.
   float inset = -1.f / contents_scale;
   blue_layer_rect1.Inset(inset, inset, inset, inset);
   blue_layer_rect2.Inset(inset, inset, inset, inset);
 
-  scoped_ptr<FakePicturePile> recording =
-      FakePicturePile::CreateFilledPile(pile_tile_size, layer_rect.size());
+  scoped_ptr<FakeDisplayListRecordingSource> recording =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(
+          layer_rect.size());
 
   Region outside(layer_rect);
   outside.Subtract(gfx::ToEnclosingRect(union_layer_rect));
   for (Region::Iterator iter(outside); iter.has_rect(); iter.next()) {
     recording->add_draw_rect_with_paint(iter.rect(), red_paint);
   }
 
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   recording->add_draw_rectf_with_paint(blue_layer_rect1, blue_paint);
   recording->add_draw_rectf_with_paint(blue_layer_rect2, blue_paint);
   recording->Rerecord();
-  scoped_refptr<FakePicturePileImpl> pile =
-      FakePicturePileImpl::CreateFromPile(recording.get(), nullptr);
+  scoped_refptr<FakeDisplayListRasterSource> raster_source =
+      FakeDisplayListRasterSource::CreateFromRecordingSource(recording.get(),
+                                                             false);
 
   gfx::Rect content_rect(
       gfx::ScaleToEnclosingRect(layer_rect, contents_scale));
   gfx::Rect content_union_rect(
       gfx::ToEnclosingRect(gfx::ScaleRect(union_layer_rect, contents_scale)));
 
   // At a scale of 4x the rectangles with a width of 2.5 will take up 10 pixels,
   // so scale an additional 10x to make them 100x100.
   gfx::Transform quad_to_target_transform;
   quad_to_target_transform.Scale(10.0, 10.0);
   gfx::Rect quad_content_rect(gfx::Size(20, 20));
   SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, quad_content_rect, pass.get());
 
   PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
   blue_quad->SetNew(blue_shared_state, quad_content_rect, gfx::Rect(),
                     quad_content_rect, gfx::RectF(quad_content_rect),
                     content_union_rect.size(), nearest_neighbor, texture_format,
-                    content_union_rect, contents_scale, pile.get());
+                    content_union_rect, contents_scale, raster_source.get());

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

but it sure is popular..

btw, you could also Pass() these raster_sources. Don't really matter cuz it's
tests, but just saying. It's pretty new, but rvalue_cast is fun amiright?

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

Changed to Pass.

 
   // Fill left half of viewport with green.
   gfx::Transform half_green_quad_to_target_transform;
   gfx::Rect half_green_rect(gfx::Size(viewport.width() / 2, viewport.height()));
   SharedQuadState* half_green_shared_state = CreateTestSharedQuadState(
       half_green_quad_to_target_transform, half_green_rect, pass.get());
   SolidColorDrawQuad* half_color_quad =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   half_color_quad->SetNew(half_green_shared_state,
                           half_green_rect,
@@ skipping 215 matching lines @@
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("wrap_mode_repeat.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace cc