cc: Added raster source.

This patch adds a raster source that is an opaque interface
for picture pile impl. It also removes the picture pile base
ref count and adds it to the raster source. This makes it
possible to use a member picture pile, instead of a ref
pointer with one owner.

What is missing here is the next step: removing picture pile
base in favour of keeping shared data on the pile and copying
it over. This should allow us to clean up the data and only
share what is actually shared.

R=danakj, enne, reveman

Review URL: https://codereview.chromium.org/666273002

Cr-Commit-Position: refs/heads/master@{#301667}

36 files changed, 586 insertions, 509 deletions

diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 84b7675..24c5833 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -367,6 +367,7 @@ component("cc") {
     "resources/priority_calculator.h",
     "resources/raster_buffer.cc",
     "resources/raster_buffer.h",
+    "resources/raster_source.h",
     "resources/raster_tile_priority_queue.cc",
     "resources/raster_tile_priority_queue.h",
     "resources/raster_worker_pool.cc",
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 39aa1c6..3c457f9 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -395,6 +395,7 @@
         'resources/priority_calculator.h',
         'resources/raster_buffer.cc',
         'resources/raster_buffer.h',
+        'resources/raster_source.h',
         'resources/raster_tile_priority_queue.cc',
         'resources/raster_tile_priority_queue.h',
         'resources/raster_worker_pool.cc',
diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index 0310b10..b984655 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -25,11 +25,11 @@ const int kDefaultRasterizeRepeatCount = 100;
 
 class BenchmarkRasterTask : public Task {
  public:
-  BenchmarkRasterTask(PicturePileImpl* picture_pile,
+  BenchmarkRasterTask(RasterSource* raster_source,
                       const gfx::Rect& content_rect,
                       float contents_scale,
                       size_t repeat_count)
-      : picture_pile_(picture_pile),
+      : raster_source_(raster_source),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         repeat_count_(repeat_count),
@@ -54,11 +54,11 @@ class BenchmarkRasterTask : public Task {
         bitmap.allocPixels(SkImageInfo::MakeN32Premul(content_rect_.width(),
                                                       content_rect_.height()));
         SkCanvas canvas(bitmap);
-        PicturePileImpl::Analysis analysis;
+        RasterSource::SolidColorAnalysis analysis;
 
-        picture_pile_->AnalyzeInRect(
+        raster_source_->PerformSolidColorAnalysis(
             content_rect_, contents_scale_, &analysis, nullptr);
-        picture_pile_->RasterToBitmap(
+        raster_source_->PlaybackToCanvas(
             &canvas, content_rect_, contents_scale_, nullptr);
 
         is_solid_color_ = analysis.is_solid_color;
@@ -78,7 +78,7 @@ class BenchmarkRasterTask : public Task {
  private:
   ~BenchmarkRasterTask() override {}
 
-  PicturePileImpl* picture_pile_;
+  RasterSource* raster_source_;
   gfx::Rect content_rect_;
   float contents_scale_;
   size_t repeat_count_;
@@ -99,7 +99,9 @@ class FixedInvalidationPictureLayerTilingClient
     return base_client_->CreateTile(tiling, content_rect);
   }
 
-  PicturePileImpl* GetPile() override { return base_client_->GetPile(); }
+  RasterSource* GetRasterSource() override {
+    return base_client_->GetRasterSource();
+  }
 
   gfx::Size CalculateTileSize(const gfx::Size& content_bounds) const override {
     return base_client_->CalculateTileSize(content_bounds);
@@ -222,12 +224,12 @@ void RasterizeAndRecordBenchmarkImpl::RunOnLayer(PictureLayerImpl* layer) {
        ++it) {
     DCHECK(*it);
 
-    PicturePileImpl* picture_pile = (*it)->picture_pile();
+    RasterSource* raster_source = (*it)->raster_source();
     gfx::Rect content_rect = (*it)->content_rect();
     float contents_scale = (*it)->contents_scale();
 
     scoped_refptr<BenchmarkRasterTask> benchmark_raster_task(
-        new BenchmarkRasterTask(picture_pile,
+        new BenchmarkRasterTask(raster_source,
                                 content_rect,
                                 contents_scale,
                                 rasterize_repeat_count_));
diff --git a/cc/layers/picture_layer.cc b/cc/layers/picture_layer.cc
index 4d44f00..6e5ba79 100644
--- a/cc/layers/picture_layer.cc
+++ b/cc/layers/picture_layer.cc
@@ -19,7 +19,6 @@ scoped_refptr<PictureLayer> PictureLayer::Create(ContentLayerClient* client) {
 
 PictureLayer::PictureLayer(ContentLayerClient* client)
     : client_(client),
-      pile_(make_scoped_refptr(new PicturePile())),
       instrumentation_object_tracker_(id()),
       update_source_frame_number_(-1),
       can_use_lcd_text_last_frame_(can_use_lcd_text()) {
@@ -40,29 +39,29 @@ void PictureLayer::PushPropertiesTo(LayerImpl* base_layer) {
     // Update may not get called for an empty layer, so resize here instead.
     // Using layer_impl because either bounds() or paint_properties().bounds
     // may disagree and either one could have been pushed to layer_impl.
-    pile_->SetEmptyBounds();
+    pile_.SetEmptyBounds();
   } else {
     // If update called, then pile size must match bounds pushed to impl layer.
     DCHECK_IMPLIES(
         update_source_frame_number_ == layer_tree_host()->source_frame_number(),
-        layer_impl->bounds().ToString() == pile_->tiling_size().ToString());
+        layer_impl->bounds().ToString() == pile_.tiling_size().ToString());
   }
 
   // Unlike other properties, invalidation must always be set on layer_impl.
   // See PictureLayerImpl::PushPropertiesTo for more details.
   layer_impl->invalidation_.Clear();
   layer_impl->invalidation_.Swap(&pile_invalidation_);
-  layer_impl->pile_ = PicturePileImpl::CreateFromOther(pile_.get());
+  layer_impl->pile_ = PicturePileImpl::CreateFromOther(&pile_);
 }
 
 void PictureLayer::SetLayerTreeHost(LayerTreeHost* host) {
   Layer::SetLayerTreeHost(host);
   if (host) {
-    pile_->SetMinContentsScale(host->settings().minimum_contents_scale);
-    pile_->SetTileGridSize(host->settings().default_tile_grid_size);
-    pile_->set_slow_down_raster_scale_factor(
+    pile_.SetMinContentsScale(host->settings().minimum_contents_scale);
+    pile_.SetTileGridSize(host->settings().default_tile_grid_size);
+    pile_.set_slow_down_raster_scale_factor(
         host->debug_state().slow_down_raster_scale_factor);
-    pile_->set_show_debug_picture_borders(
+    pile_.set_show_debug_picture_borders(
         host->debug_state().show_picture_borders);
   }
 }
@@ -92,7 +91,7 @@ bool PictureLayer::Update(ResourceUpdateQueue* queue,
   gfx::Size layer_size = paint_properties().bounds;
 
   if (last_updated_visible_content_rect_ == visible_content_rect() &&
-      pile_->tiling_size() == layer_size && pending_invalidation_.IsEmpty()) {
+      pile_.tiling_size() == layer_size && pending_invalidation_.IsEmpty()) {
     // Only early out if the visible content rect of this layer hasn't changed.
     return updated;
   }
@@ -120,16 +119,16 @@ bool PictureLayer::Update(ResourceUpdateQueue* queue,
   // for them.
   DCHECK(client_);
   updated |=
-      pile_->UpdateAndExpandInvalidation(client_,
-                                         &pile_invalidation_,
-                                         SafeOpaqueBackgroundColor(),
-                                         contents_opaque(),
-                                         client_->FillsBoundsCompletely(),
-                                         layer_size,
-                                         visible_layer_rect,
-                                         update_source_frame_number_,
-                                         Picture::RECORD_NORMALLY,
-                                         rendering_stats_instrumentation());
+      pile_.UpdateAndExpandInvalidation(client_,
+                                        &pile_invalidation_,
+                                        SafeOpaqueBackgroundColor(),
+                                        contents_opaque(),
+                                        client_->FillsBoundsCompletely(),
+                                        layer_size,
+                                        visible_layer_rect,
+                                        update_source_frame_number_,
+                                        Picture::RECORD_NORMALLY,
+                                        rendering_stats_instrumentation());
   last_updated_visible_content_rect_ = visible_content_rect();
 
   if (updated) {
@@ -144,7 +143,7 @@ bool PictureLayer::Update(ResourceUpdateQueue* queue,
 }
 
 void PictureLayer::SetIsMask(bool is_mask) {
-  pile_->set_is_mask(is_mask);
+  pile_.set_is_mask(is_mask);
 }
 
 bool PictureLayer::SupportsLCDText() const {
@@ -180,7 +179,7 @@ skia::RefPtr<SkPicture> PictureLayer::GetPicture() const {
 }
 
 bool PictureLayer::IsSuitableForGpuRasterization() const {
-  return pile_->is_suitable_for_gpu_rasterization();
+  return pile_.is_suitable_for_gpu_rasterization();
 }
 
 void PictureLayer::ClearClient() {
diff --git a/cc/layers/picture_layer.h b/cc/layers/picture_layer.h
index 0ba26e6..232dba2 100644
--- a/cc/layers/picture_layer.h
+++ b/cc/layers/picture_layer.h
@@ -39,7 +39,7 @@ class CC_EXPORT PictureLayer : public Layer {
 
   ContentLayerClient* client() { return client_; }
 
-  PicturePile* GetPicturePileForTesting() const { return pile_.get(); }
+  PicturePile* GetPicturePileForTesting() { return &pile_; }
 
  protected:
   explicit PictureLayer(ContentLayerClient* client);
@@ -50,7 +50,7 @@ class CC_EXPORT PictureLayer : public Layer {
 
  private:
   ContentLayerClient* client_;
-  scoped_refptr<PicturePile> pile_;
+  PicturePile pile_;
   devtools_instrumentation::
       ScopedLayerObjectTracker instrumentation_object_tracker_;
   // Invalidation to use the next time update is called.
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index aacabde..7fd7730 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -646,7 +646,7 @@ scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
       flags);
 }
 
-PicturePileImpl* PictureLayerImpl::GetPile() {
+RasterSource* PictureLayerImpl::GetRasterSource() {
   return pile_.get();
 }
 
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index 9350dc8..c5aab85 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -119,7 +119,7 @@ class CC_EXPORT PictureLayerImpl
   // PictureLayerTilingClient overrides.
   scoped_refptr<Tile> CreateTile(PictureLayerTiling* tiling,
                                  const gfx::Rect& content_rect) override;
-  PicturePileImpl* GetPile() override;
+  RasterSource* GetRasterSource() override;
   gfx::Size CalculateTileSize(const gfx::Size& content_bounds) const override;
   const Region* GetPendingInvalidation() override;
   const PictureLayerTiling* GetPendingOrActiveTwinTiling(
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index c47ba95..c063ef5 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -188,7 +188,7 @@ class PictureLayerImplTest : public testing::Test {
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
-      EXPECT_EQ(pile, iter->picture_pile());
+      EXPECT_EQ(pile, iter->raster_source());
     }
   }
 
@@ -540,9 +540,9 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       if (iter.geometry_rect().Intersects(content_invalidation))
-        EXPECT_EQ(pending_pile.get(), iter->picture_pile());
+        EXPECT_EQ(pending_pile.get(), iter->raster_source());
       else
-        EXPECT_EQ(active_pile.get(), iter->picture_pile());
+        EXPECT_EQ(active_pile.get(), iter->raster_source());
     }
   }
 }
@@ -609,9 +609,9 @@ TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) {
           iter.geometry_rect().bottom() >= active_content_bounds.height() ||
           active_tiles[0]->content_rect().size() !=
               pending_tiles[0]->content_rect().size()) {
-        EXPECT_EQ(pending_pile.get(), iter->picture_pile());
+        EXPECT_EQ(pending_pile.get(), iter->raster_source());
       } else {
-        EXPECT_EQ(active_pile.get(), iter->picture_pile());
+        EXPECT_EQ(active_pile.get(), iter->raster_source());
       }
     }
   }
@@ -664,9 +664,9 @@ TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) {
                                               iter.full_tile_geometry_rect());
 
       if (in_pending && !in_active)
-        EXPECT_EQ(pending_pile.get(), iter->picture_pile());
+        EXPECT_EQ(pending_pile.get(), iter->raster_source());
       else if (in_active)
-        EXPECT_EQ(active_pile.get(), iter->picture_pile());
+        EXPECT_EQ(active_pile.get(), iter->raster_source());
       else
         EXPECT_FALSE(*iter);
     }
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index d07f4d2..941f45d 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -2031,7 +2031,7 @@ void GLRenderer::DrawPictureQuad(const DrawingFrame* frame,
   }
 
   SkCanvas canvas(on_demand_tile_raster_bitmap_);
-  quad->picture_pile->RasterToBitmap(
+  quad->picture_pile->PlaybackToCanvas(
       &canvas, quad->content_rect, quad->contents_scale, NULL);
 
   uint8_t* bitmap_pixels = NULL;
diff --git a/cc/resources/bitmap_raster_worker_pool.cc b/cc/resources/bitmap_raster_worker_pool.cc
index fd16ca3..f58f293 100644
--- a/cc/resources/bitmap_raster_worker_pool.cc
+++ b/cc/resources/bitmap_raster_worker_pool.cc
@@ -10,8 +10,8 @@
 #include "base/debug/trace_event_argument.h"
 #include "base/strings/stringprintf.h"
 #include "cc/debug/traced_value.h"
-#include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/raster_buffer.h"
+#include "cc/resources/raster_source.h"
 #include "cc/resources/resource.h"
 
 namespace cc {
@@ -24,11 +24,11 @@ class RasterBufferImpl : public RasterBuffer {
       : lock_(resource_provider, resource->id()) {}
 
   // Overridden from RasterBuffer:
-  void Playback(const PicturePileImpl* picture_pile,
+  void Playback(const RasterSource* raster_source,
                 const gfx::Rect& rect,
                 float scale,
                 RenderingStatsInstrumentation* stats) override {
-    picture_pile->RasterToBitmap(lock_.sk_canvas(), rect, scale, stats);
+    raster_source->PlaybackToCanvas(lock_.sk_canvas(), rect, scale, stats);
   }
 
  private:
diff --git a/cc/resources/gpu_raster_worker_pool.cc b/cc/resources/gpu_raster_worker_pool.cc
index cba427e..3237500 100644
--- a/cc/resources/gpu_raster_worker_pool.cc
+++ b/cc/resources/gpu_raster_worker_pool.cc
@@ -8,8 +8,8 @@
 
 #include "base/debug/trace_event.h"
 #include "cc/output/context_provider.h"
-#include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/raster_buffer.h"
+#include "cc/resources/raster_source.h"
 #include "cc/resources/resource.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_gpu_raster.h"
@@ -34,14 +34,14 @@ class RasterBufferImpl : public RasterBuffer {
         use_distance_field_text_(use_distance_field_text) {}
 
   // Overridden from RasterBuffer:
-  void Playback(const PicturePileImpl* picture_pile,
+  void Playback(const RasterSource* raster_source,
                 const gfx::Rect& rect,
                 float scale,
                 RenderingStatsInstrumentation* stats) override {
     // Turn on distance fields for layers that have ever animated.
     bool use_distance_field_text =
         use_distance_field_text_ ||
-        picture_pile->likely_to_be_used_for_transform_animation();
+        raster_source->SuitableForDistanceFieldText();
     SkSurface* sk_surface = lock_.GetSkSurface(use_distance_field_text);
 
     if (!sk_surface)
@@ -53,7 +53,7 @@ class RasterBufferImpl : public RasterBuffer {
         skia::SharePtr(recorder.beginRecording(size.width(), size.height()));
 
     canvas->save();
-    picture_pile->RasterToBitmap(canvas.get(), rect, scale, stats);
+    raster_source->PlaybackToCanvas(canvas.get(), rect, scale, stats);
     canvas->restore();
 
     // Add the canvas and recorded picture to |multi_picture_draw_|.
diff --git a/cc/resources/one_copy_raster_worker_pool.cc b/cc/resources/one_copy_raster_worker_pool.cc
index bf7c68e..831bb76 100644
--- a/cc/resources/one_copy_raster_worker_pool.cc
+++ b/cc/resources/one_copy_raster_worker_pool.cc
@@ -51,7 +51,7 @@ class RasterBufferImpl : public RasterBuffer {
   }
 
   // Overridden from RasterBuffer:
-  void Playback(const PicturePileImpl* picture_pile,
+  void Playback(const RasterSource* raster_source,
                 const gfx::Rect& rect,
                 float scale,
                 RenderingStatsInstrumentation* stats) override {
@@ -63,7 +63,7 @@ class RasterBufferImpl : public RasterBuffer {
                                        raster_resource_->format(),
                                        raster_resource_->size(),
                                        gpu_memory_buffer->GetStride(),
-                                       picture_pile,
+                                       raster_source,
                                        rect,
                                        scale,
                                        stats);
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 771826f..61b0362 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -250,9 +250,9 @@ void PictureLayerTiling::UpdateTilesToCurrentPile(
     Invalidate(layer_invalidation);
   }
 
-  PicturePileImpl* pile = client_->GetPile();
+  RasterSource* raster_source = client_->GetRasterSource();
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-    it->second->set_picture_pile(pile);
+    it->second->set_raster_source(raster_source);
   VerifyLiveTilesRect();
 }
 
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index fba3df3..17da548 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -38,7 +38,7 @@ class CC_EXPORT PictureLayerTilingClient {
   virtual scoped_refptr<Tile> CreateTile(
     PictureLayerTiling* tiling,
     const gfx::Rect& content_rect) = 0;
-  virtual PicturePileImpl* GetPile() = 0;
+  virtual RasterSource* GetRasterSource() = 0;
   virtual gfx::Size CalculateTileSize(
     const gfx::Size& content_bounds) const = 0;
   // This invalidation region defines the area (if any, it can by null) that
diff --git a/cc/resources/picture_layer_tiling_set_unittest.cc b/cc/resources/picture_layer_tiling_set_unittest.cc
index 2005175..0fe8b3c 100644
--- a/cc/resources/picture_layer_tiling_set_unittest.cc
+++ b/cc/resources/picture_layer_tiling_set_unittest.cc
@@ -354,11 +354,11 @@ class PictureLayerTilingSetSyncTest : public testing::Test {
     }
 
     for (size_t i = 0; i < target_->num_tilings(); ++i)
-      ValidateTiling(target_->tiling_at(i), target_client_.GetPile());
+      ValidateTiling(target_->tiling_at(i), target_client_.GetRasterSource());
   }
 
   void ValidateTiling(const PictureLayerTiling* tiling,
-                      const PicturePileImpl* pile) {
+                      const RasterSource* raster_source) {
     if (tiling->tiling_size().IsEmpty()) {
       EXPECT_TRUE(tiling->live_tiles_rect().IsEmpty());
     } else if (!tiling->live_tiles_rect().IsEmpty()) {
@@ -370,7 +370,7 @@ class PictureLayerTilingSetSyncTest : public testing::Test {
     for (size_t i = 0; i < tiles.size(); ++i) {
       const Tile* tile = tiles[i];
       ASSERT_TRUE(!!tile);
-      EXPECT_EQ(tile->picture_pile(), pile);
+      EXPECT_EQ(tile->raster_source(), raster_source);
       EXPECT_TRUE(tile->content_rect().Intersects(tiling->live_tiles_rect()))
           << "All tiles must be inside the live tiles rect."
           << " Tile rect: " << tile->content_rect().ToString()
diff --git a/cc/resources/picture_pile.h b/cc/resources/picture_pile.h
index 595ded4..7cd2229 100644
--- a/cc/resources/picture_pile.h
+++ b/cc/resources/picture_pile.h
@@ -5,6 +5,7 @@
 #ifndef CC_RESOURCES_PICTURE_PILE_H_
 #define CC_RESOURCES_PICTURE_PILE_H_
 
+#include "base/memory/ref_counted.h"
 #include "cc/resources/picture_pile_base.h"
 #include "ui/gfx/geometry/rect.h"
 
@@ -16,6 +17,7 @@ class RenderingStatsInstrumentation;
 class CC_EXPORT PicturePile : public PicturePileBase {
  public:
   PicturePile();
+  ~PicturePile() override;
 
   // Re-record parts of the picture that are invalid.
   // Invalidations are in layer space, and will be expanded to cover everything
@@ -53,9 +55,6 @@ class CC_EXPORT PicturePile : public PicturePileBase {
 
   void SetPixelRecordDistanceForTesting(int d) { pixel_record_distance_ = d; }
 
- protected:
-  ~PicturePile() override;
-
  private:
   friend class PicturePileImpl;
 
diff --git a/cc/resources/picture_pile_base.cc b/cc/resources/picture_pile_base.cc
index 45db791..7cb0d1b 100644
--- a/cc/resources/picture_pile_base.cc
+++ b/cc/resources/picture_pile_base.cc
@@ -142,7 +142,7 @@ bool PicturePileBase::HasRecordingAt(int x, int y) {
 }
 
 bool PicturePileBase::CanRaster(float contents_scale,
-                                const gfx::Rect& content_rect) {
+                                const gfx::Rect& content_rect) const {
   if (tiling_.tiling_size().IsEmpty())
     return false;
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
diff --git a/cc/resources/picture_pile_base.h b/cc/resources/picture_pile_base.h
index 07540cb..9355e38 100644
--- a/cc/resources/picture_pile_base.h
+++ b/cc/resources/picture_pile_base.h
@@ -10,7 +10,6 @@
 #include <utility>
 
 #include "base/containers/hash_tables.h"
-#include "base/memory/ref_counted.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/region.h"
 #include "cc/base/tiling_data.h"
@@ -26,8 +25,7 @@ class Value;
 
 namespace cc {
 
-class CC_EXPORT PicturePileBase
-    : public base::RefCountedThreadSafe<PicturePileBase> {
+class CC_EXPORT PicturePileBase {
  public:
   PicturePileBase();
   explicit PicturePileBase(const PicturePileBase* other);
@@ -44,7 +42,7 @@ class CC_EXPORT PicturePileBase
   int num_tiles_y() const { return tiling_.num_tiles_y(); }
   gfx::Rect tile_bounds(int x, int y) const { return tiling_.TileBounds(x, y); }
   bool HasRecordingAt(int x, int y);
-  bool CanRaster(float contents_scale, const gfx::Rect& content_rect);
+  bool CanRaster(float contents_scale, const gfx::Rect& content_rect) const;
 
   // If this pile contains any valid recordings. May have false positives.
   bool HasRecordings() const { return has_any_recordings_; }
@@ -137,7 +135,6 @@ class CC_EXPORT PicturePileBase
  private:
   void SetBufferPixels(int buffer_pixels);
 
-  friend class base::RefCountedThreadSafe<PicturePileBase>;
   DISALLOW_COPY_AND_ASSIGN(PicturePileBase);
 };
 
diff --git a/cc/resources/picture_pile_impl.cc b/cc/resources/picture_pile_impl.cc
index e8cee1e..f7c24c7 100644
--- a/cc/resources/picture_pile_impl.cc
+++ b/cc/resources/picture_pile_impl.cc
@@ -41,7 +41,7 @@ void PicturePileImpl::RasterDirect(
     SkCanvas* canvas,
     const gfx::Rect& canvas_rect,
     float contents_scale,
-    RenderingStatsInstrumentation* rendering_stats_instrumentation) {
+    RenderingStatsInstrumentation* rendering_stats_instrumentation) const {
   RasterCommon(canvas,
                NULL,
                canvas_rect,
@@ -59,7 +59,7 @@ void PicturePileImpl::RasterForAnalysis(
       canvas, canvas, canvas_rect, contents_scale, stats_instrumentation, true);
 }
 
-void PicturePileImpl::RasterToBitmap(
+void PicturePileImpl::PlaybackToCanvas(
     SkCanvas* canvas,
     const gfx::Rect& canvas_rect,
     float contents_scale,
@@ -316,25 +316,19 @@ skia::RefPtr<SkPicture> PicturePileImpl::GetFlattenedPicture() {
   SkCanvas* canvas =
       recorder.beginRecording(tiling_rect.width(), tiling_rect.height());
   if (!tiling_rect.IsEmpty())
-    RasterToBitmap(canvas, tiling_rect, 1.0, NULL);
+    PlaybackToCanvas(canvas, tiling_rect, 1.0, NULL);
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
 
   return picture;
 }
 
-void PicturePileImpl::AnalyzeInRect(const gfx::Rect& content_rect,
-                                    float contents_scale,
-                                    PicturePileImpl::Analysis* analysis) const {
-  AnalyzeInRect(content_rect, contents_scale, analysis, NULL);
-}
-
-void PicturePileImpl::AnalyzeInRect(
+void PicturePileImpl::PerformSolidColorAnalysis(
     const gfx::Rect& content_rect,
     float contents_scale,
-    PicturePileImpl::Analysis* analysis,
+    RasterSource::SolidColorAnalysis* analysis,
     RenderingStatsInstrumentation* stats_instrumentation) const {
   DCHECK(analysis);
-  TRACE_EVENT0("cc", "PicturePileImpl::AnalyzeInRect");
+  TRACE_EVENT0("cc", "PicturePileImpl::PerformSolidColorAnalysis");
 
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
       content_rect, 1.0f / contents_scale);
@@ -348,14 +342,24 @@ void PicturePileImpl::AnalyzeInRect(
   analysis->is_solid_color = canvas.GetColorIfSolid(&analysis->solid_color);
 }
 
-// Since there are situations when we can skip analysis, the variables have to
-// be set to their safest values. That is, we have to assume that the tile is
-// not solid color. As well, we have to assume that the tile has text so we
-// don't early out incorrectly.
-PicturePileImpl::Analysis::Analysis() : is_solid_color(false) {
+void PicturePileImpl::GatherPixelRefs(
+    const gfx::Rect& content_rect,
+    float contents_scale,
+    std::vector<SkPixelRef*>* pixel_refs) const {
+  DCHECK_EQ(0u, pixel_refs->size());
+  for (PixelRefIterator iter(content_rect, contents_scale, this); iter;
+       ++iter) {
+    pixel_refs->push_back(*iter);
+  }
+}
+
+bool PicturePileImpl::CoversRect(const gfx::Rect& content_rect,
+                                 float contents_scale) const {
+  return CanRaster(contents_scale, content_rect);
 }
 
-PicturePileImpl::Analysis::~Analysis() {
+bool PicturePileImpl::SuitableForDistanceFieldText() const {
+  return likely_to_be_used_for_transform_animation_;
 }
 
 PicturePileImpl::PixelRefIterator::PixelRefIterator(
diff --git a/cc/resources/picture_pile_impl.h b/cc/resources/picture_pile_impl.h
index 243601e..1eb2187 100644
--- a/cc/resources/picture_pile_impl.h
+++ b/cc/resources/picture_pile_impl.h
@@ -14,75 +14,58 @@
 #include "cc/base/cc_export.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/resources/picture_pile_base.h"
+#include "cc/resources/raster_source.h"
 #include "skia/ext/analysis_canvas.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkPicture.h"
 
 namespace cc {
 
-class CC_EXPORT PicturePileImpl : public PicturePileBase {
+// TODO(vmpstr): Clean up PicturePileBase and make it a member.
+class CC_EXPORT PicturePileImpl : public PicturePileBase, public RasterSource {
  public:
   static scoped_refptr<PicturePileImpl> Create();
   static scoped_refptr<PicturePileImpl> CreateFromOther(
       const PicturePileBase* other);
 
-  // Raster a subrect of this PicturePileImpl into the given canvas. It is
-  // assumed that contents_scale has already been applied to this canvas.
-  // Writes the total number of pixels rasterized and the time spent
-  // rasterizing to the stats if the respective pointer is not NULL. When
-  // slow-down-raster-scale-factor is set to a value greater than 1, the
-  // reported rasterize time is the minimum measured value over all runs.
-  void RasterDirect(
+  // RasterSource overrides. See RasterSource header for full description.
+  // When slow-down-raster-scale-factor is set to a value greater than 1, the
+  // reported rasterize time (in stats_instrumentation) is the minimum measured
+  // value over all runs.
+  void PlaybackToCanvas(
       SkCanvas* canvas,
       const gfx::Rect& canvas_rect,
       float contents_scale,
-      RenderingStatsInstrumentation* rendering_stats_instrumentation);
-
-  // Similar to the above RasterDirect method, but this is a convenience method
-  // for when it is known that the raster is going to an intermediate bitmap
-  // that itself will then be blended and thus that a canvas clear is required.
-  // Note that this function may write outside the canvas_rect.
-  void RasterToBitmap(
-      SkCanvas* canvas,
-      const gfx::Rect& canvas_rect,
+      RenderingStatsInstrumentation* stats_instrumentation) const override;
+  void PerformSolidColorAnalysis(
+      const gfx::Rect& content_rect,
       float contents_scale,
-      RenderingStatsInstrumentation* stats_instrumentation) const;
+      RasterSource::SolidColorAnalysis* analysis,
+      RenderingStatsInstrumentation* stats_instrumentation) const override;
+  void GatherPixelRefs(const gfx::Rect& content_rect,
+                       float contents_scale,
+                       std::vector<SkPixelRef*>* pixel_refs) const override;
+  bool CoversRect(const gfx::Rect& content_rect,
+                  float contents_scale) const override;
+  bool SuitableForDistanceFieldText() const override;
 
-  // Called when analyzing a tile. We can use AnalysisCanvas as
-  // SkDrawPictureCallback, which allows us to early out from analysis.
-  void RasterForAnalysis(
-      skia::AnalysisCanvas* canvas,
+  // Raster into the canvas without applying clips.
+  void RasterDirect(
+      SkCanvas* canvas,
       const gfx::Rect& canvas_rect,
       float contents_scale,
-      RenderingStatsInstrumentation* stats_instrumentation) const;
+      RenderingStatsInstrumentation* rendering_stats_instrumentation) const;
 
+  // Tracing functionality.
+  void DidBeginTracing();
   skia::RefPtr<SkPicture> GetFlattenedPicture();
 
-  bool likely_to_be_used_for_transform_animation() const {
-    return likely_to_be_used_for_transform_animation_;
-  }
   void set_likely_to_be_used_for_transform_animation() {
     likely_to_be_used_for_transform_animation_ = true;
   }
 
-  struct CC_EXPORT Analysis {
-    Analysis();
-    ~Analysis();
-
-    bool is_solid_color;
-    SkColor solid_color;
-  };
-
-  void AnalyzeInRect(const gfx::Rect& content_rect,
-                     float contents_scale,
-                     Analysis* analysis) const;
-
-  void AnalyzeInRect(
-      const gfx::Rect& content_rect,
-      float contents_scale,
-      Analysis* analysis,
-      RenderingStatsInstrumentation* stats_instrumentation) const;
-
+  // Iterator used to return SkPixelRefs from this picture pile.
+  // Public for testing.
   class CC_EXPORT PixelRefIterator {
    public:
     PixelRefIterator(const gfx::Rect& content_rect,
@@ -105,8 +88,6 @@ class CC_EXPORT PicturePileImpl : public PicturePileBase {
     std::set<const void*> processed_pictures_;
   };
 
-  void DidBeginTracing();
-
  protected:
   friend class PicturePile;
   friend class PixelRefIterator;
@@ -118,6 +99,14 @@ class CC_EXPORT PicturePileImpl : public PicturePileBase {
  private:
   typedef std::map<const Picture*, Region> PictureRegionMap;
 
+  // Called when analyzing a tile. We can use AnalysisCanvas as
+  // SkDrawPictureCallback, which allows us to early out from analysis.
+  void RasterForAnalysis(
+      skia::AnalysisCanvas* canvas,
+      const gfx::Rect& canvas_rect,
+      float contents_scale,
+      RenderingStatsInstrumentation* stats_instrumentation) const;
+
   void CoalesceRasters(const gfx::Rect& canvas_rect,
                        const gfx::Rect& content_rect,
                        float contents_scale,
diff --git a/cc/resources/picture_pile_impl_perftest.cc b/cc/resources/picture_pile_impl_perftest.cc
index 7f12fd1..e3bbac7 100644
--- a/cc/resources/picture_pile_impl_perftest.cc
+++ b/cc/resources/picture_pile_impl_perftest.cc
@@ -33,10 +33,11 @@ class PicturePileImplPerfTest : public testing::Test {
     // Content rect that will align with top-left tile at scale 1.0.
     gfx::Rect content_rect(0, 0, kTileSize, kTileSize);
 
-    PicturePileImpl::Analysis analysis;
+    RasterSource::SolidColorAnalysis analysis;
     timer_.Reset();
     do {
-      pile->AnalyzeInRect(content_rect, contents_scale, &analysis);
+      pile->PerformSolidColorAnalysis(
+          content_rect, contents_scale, &analysis, nullptr);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
@@ -57,10 +58,10 @@ class PicturePileImplPerfTest : public testing::Test {
     FakeRenderingStatsInstrumentation rendering_stats_instrumentation;
     timer_.Reset();
     do {
-      pile->RasterToBitmap(&canvas,
-                           content_rect,
-                           contents_scale,
-                           &rendering_stats_instrumentation);
+      pile->PlaybackToCanvas(&canvas,
+                             content_rect,
+                             contents_scale,
+                             &rendering_stats_instrumentation);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
diff --git a/cc/resources/picture_pile_impl_unittest.cc b/cc/resources/picture_pile_impl_unittest.cc
index 0ced279..bd796a5 100644
--- a/cc/resources/picture_pile_impl_unittest.cc
+++ b/cc/resources/picture_pile_impl_unittest.cc
@@ -37,9 +37,9 @@ TEST(PicturePileImplTest, AnalyzeIsSolidUnscaled) {
   // Ensure everything is solid
   for (int y = 0; y <= 300; y += 100) {
     for (int x = 0; x <= 300; x += 100) {
-      PicturePileImpl::Analysis analysis;
+      RasterSource::SolidColorAnalysis analysis;
       gfx::Rect rect(x, y, 100, 100);
-      pile->AnalyzeInRect(rect, 1.0, &analysis);
+      pile->PerformSolidColorAnalysis(rect, 1.0, &analysis, nullptr);
       EXPECT_TRUE(analysis.is_solid_color) << rect.ToString();
       EXPECT_EQ(analysis.solid_color, solid_color) << rect.ToString();
     }
@@ -49,27 +49,32 @@ TEST(PicturePileImplTest, AnalyzeIsSolidUnscaled) {
   pile->add_draw_rect_with_paint(gfx::Rect(50, 50, 1, 1), non_solid_paint);
   pile->RerecordPile();
 
-  PicturePileImpl::Analysis analysis;
-  pile->AnalyzeInRect(gfx::Rect(0, 0, 100, 100), 1.0, &analysis);
+  RasterSource::SolidColorAnalysis analysis;
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(0, 0, 100, 100), 1.0, &analysis, nullptr);
   EXPECT_FALSE(analysis.is_solid_color);
 
-  pile->AnalyzeInRect(gfx::Rect(100, 0, 100, 100), 1.0, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(100, 0, 100, 100), 1.0, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   // Boundaries should be clipped
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(350, 0, 100, 100), 1.0, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(350, 0, 100, 100), 1.0, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(0, 350, 100, 100), 1.0, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(0, 350, 100, 100), 1.0, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(350, 350, 100, 100), 1.0, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(350, 350, 100, 100), 1.0, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 }
@@ -95,9 +100,9 @@ TEST(PicturePileImplTest, AnalyzeIsSolidScaled) {
   // Ensure everything is solid
   for (int y = 0; y <= 30; y += 10) {
     for (int x = 0; x <= 30; x += 10) {
-      PicturePileImpl::Analysis analysis;
+      RasterSource::SolidColorAnalysis analysis;
       gfx::Rect rect(x, y, 10, 10);
-      pile->AnalyzeInRect(rect, 0.1f, &analysis);
+      pile->PerformSolidColorAnalysis(rect, 0.1f, &analysis, nullptr);
       EXPECT_TRUE(analysis.is_solid_color) << rect.ToString();
       EXPECT_EQ(analysis.solid_color, solid_color) << rect.ToString();
     }
@@ -107,27 +112,32 @@ TEST(PicturePileImplTest, AnalyzeIsSolidScaled) {
   pile->add_draw_rect_with_paint(gfx::Rect(50, 50, 1, 1), non_solid_paint);
   pile->RerecordPile();
 
-  PicturePileImpl::Analysis analysis;
-  pile->AnalyzeInRect(gfx::Rect(0, 0, 10, 10), 0.1f, &analysis);
+  RasterSource::SolidColorAnalysis analysis;
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(0, 0, 10, 10), 0.1f, &analysis, nullptr);
   EXPECT_FALSE(analysis.is_solid_color);
 
-  pile->AnalyzeInRect(gfx::Rect(10, 0, 10, 10), 0.1f, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(10, 0, 10, 10), 0.1f, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   // Boundaries should be clipped
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(35, 0, 10, 10), 0.1f, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(35, 0, 10, 10), 0.1f, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(0, 35, 10, 10), 0.1f, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(0, 35, 10, 10), 0.1f, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(35, 35, 10, 10), 0.1f, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(35, 35, 10, 10), 0.1f, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 }
@@ -138,10 +148,11 @@ TEST(PicturePileImplTest, AnalyzeIsSolidEmpty) {
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  PicturePileImpl::Analysis analysis;
+  RasterSource::SolidColorAnalysis analysis;
   EXPECT_FALSE(analysis.is_solid_color);
 
-  pile->AnalyzeInRect(gfx::Rect(0, 0, 400, 400), 1.f, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(0, 0, 400, 400), 1.f, &analysis, nullptr);
 
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, SkColorSetARGB(0, 0, 0, 0));
@@ -687,10 +698,10 @@ TEST_P(FullContentsTest, RasterFullContents) {
 
       FakeRenderingStatsInstrumentation rendering_stats_instrumentation;
 
-      pile->RasterToBitmap(&canvas,
-                           canvas_rect,
-                           contents_scale,
-                           &rendering_stats_instrumentation);
+      pile->PlaybackToCanvas(&canvas,
+                             canvas_rect,
+                             contents_scale,
+                             &rendering_stats_instrumentation);
 
       SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
       int num_pixels = bitmap.width() * bitmap.height();
@@ -738,7 +749,7 @@ TEST(PicturePileImpl, RasterContentsTransparent) {
   SkCanvas canvas(bitmap);
 
   FakeRenderingStatsInstrumentation rendering_stats_instrumentation;
-  pile->RasterToBitmap(
+  pile->PlaybackToCanvas(
       &canvas, canvas_rect, contents_scale, &rendering_stats_instrumentation);
 
   SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
@@ -784,10 +795,10 @@ TEST_P(OverlapTest, NoOverlap) {
   SkCanvas canvas(bitmap);
 
   FakeRenderingStatsInstrumentation rendering_stats_instrumentation;
-  pile->RasterToBitmap(&canvas,
-                       gfx::Rect(content_bounds),
-                       contents_scale,
-                       &rendering_stats_instrumentation);
+  pile->PlaybackToCanvas(&canvas,
+                         gfx::Rect(content_bounds),
+                         contents_scale,
+                         &rendering_stats_instrumentation);
 
   for (int y = 0; y < bitmap.height(); y++) {
     for (int x = 0; x < bitmap.width(); x++) {
diff --git a/cc/resources/picture_pile_unittest.cc b/cc/resources/picture_pile_unittest.cc
index 537872d..d6d75fa 100644
--- a/cc/resources/picture_pile_unittest.cc
+++ b/cc/resources/picture_pile_unittest.cc
@@ -17,6 +17,8 @@ namespace {
 
 class TestPicturePile : public PicturePile {
  public:
+  ~TestPicturePile() override {}
+
   using PicturePile::buffer_pixels;
   using PicturePile::CanRasterSlowTileCheck;
   using PicturePile::Clear;
@@ -31,9 +33,6 @@ class TestPicturePile : public PicturePile {
   typedef PicturePile::PictureInfo PictureInfo;
   typedef PicturePile::PictureMapKey PictureMapKey;
   typedef PicturePile::PictureMap PictureMap;
-
- protected:
-  ~TestPicturePile() override {}
 };
 
 class PicturePileTestBase {
@@ -45,11 +44,10 @@ class PicturePileTestBase {
         contents_opaque_(false) {}
 
   void InitializeData() {
-    pile_ = make_scoped_refptr(new TestPicturePile());
-    pile_->SetTileGridSize(gfx::Size(1000, 1000));
-    pile_->SetMinContentsScale(min_scale_);
+    pile_.SetTileGridSize(gfx::Size(1000, 1000));
+    pile_.SetMinContentsScale(min_scale_);
     client_ = FakeContentLayerClient();
-    SetTilingSize(pile_->tiling().max_texture_size());
+    SetTilingSize(pile_.tiling().max_texture_size());
   }
 
   void SetTilingSize(const gfx::Size& tiling_size) {
@@ -58,23 +56,23 @@ class PicturePileTestBase {
     UpdateAndExpandInvalidation(&invalidation, tiling_size, viewport_rect);
   }
 
-  gfx::Size tiling_size() const { return pile_->tiling_size(); }
-  gfx::Rect tiling_rect() const { return gfx::Rect(pile_->tiling_size()); }
+  gfx::Size tiling_size() const { return pile_.tiling_size(); }
+  gfx::Rect tiling_rect() const { return gfx::Rect(pile_.tiling_size()); }
 
   bool UpdateAndExpandInvalidation(Region* invalidation,
                                    const gfx::Size& layer_size,
                                    const gfx::Rect& visible_layer_rect) {
     frame_number_++;
-    return pile_->UpdateAndExpandInvalidation(&client_,
-                                              invalidation,
-                                              background_color_,
-                                              contents_opaque_,
-                                              false,
-                                              layer_size,
-                                              visible_layer_rect,
-                                              frame_number_,
-                                              Picture::RECORD_NORMALLY,
-                                              &stats_instrumentation_);
+    return pile_.UpdateAndExpandInvalidation(&client_,
+                                             invalidation,
+                                             background_color_,
+                                             contents_opaque_,
+                                             false,
+                                             layer_size,
+                                             visible_layer_rect,
+                                             frame_number_,
+                                             Picture::RECORD_NORMALLY,
+                                             &stats_instrumentation_);
   }
 
   bool UpdateWholePile() {
@@ -87,7 +85,7 @@ class PicturePileTestBase {
 
   FakeContentLayerClient client_;
   FakeRenderingStatsInstrumentation stats_instrumentation_;
-  scoped_refptr<TestPicturePile> pile_;
+  TestPicturePile pile_;
   SkColor background_color_;
   float min_scale_;
   int frame_number_;
@@ -101,17 +99,17 @@ class PicturePileTest : public PicturePileTestBase, public testing::Test {
 
 TEST_F(PicturePileTest, InvalidationOnTileBorderOutsideInterestRect) {
   // Don't expand the interest rect past what we invalidate.
-  pile_->SetPixelRecordDistanceForTesting(0);
+  pile_.SetPixelRecordDistanceForTesting(0);
 
   gfx::Size tile_size(100, 100);
-  pile_->tiling().SetMaxTextureSize(tile_size);
+  pile_.tiling().SetMaxTextureSize(tile_size);
 
   gfx::Size pile_size(400, 400);
   SetTilingSize(pile_size);
 
   // We have multiple tiles.
-  EXPECT_GT(pile_->tiling().num_tiles_x(), 2);
-  EXPECT_GT(pile_->tiling().num_tiles_y(), 2);
+  EXPECT_GT(pile_.tiling().num_tiles_x(), 2);
+  EXPECT_GT(pile_.tiling().num_tiles_y(), 2);
 
   // Record everything.
   Region invalidation(tiling_rect());
@@ -145,10 +143,10 @@ TEST_F(PicturePileTest, InvalidationOnTileBorderOutsideInterestRect) {
   // This is the VV interest rect which will be entirely inside 1,0 and not
   // touch the border of 1,1.
   gfx::Rect interest_rect(
-      pile_->tiling().TilePositionX(1) + pile_->tiling().border_texels(),
+      pile_.tiling().TilePositionX(1) + pile_.tiling().border_texels(),
       0,
       10,
-      pile_->tiling().TileSizeY(0) - pile_->tiling().border_texels());
+      pile_.tiling().TileSizeY(0) - pile_.tiling().border_texels());
 
   // Invalidate tile 1,0 only. This is a rect that avoids the borders of any
   // other tiles.
@@ -171,7 +169,7 @@ TEST_F(PicturePileTest, InvalidationOnTileBorderOutsideInterestRect) {
   invalidation = invalidate_border;
   UpdateAndExpandInvalidation(&invalidation, tiling_size(), interest_rect);
   Region expected_invalidation = invalidate_border;
-  expected_invalidation.Union(pile_->tiling().TileBounds(1, 1));
+  expected_invalidation.Union(pile_.tiling().TileBounds(1, 1));
   EXPECT_EQ(expected_invalidation.ToString(), invalidation.ToString());
 }
 
@@ -181,11 +179,11 @@ TEST_F(PicturePileTest, SmallInvalidateInflated) {
   UpdateAndExpandInvalidation(&invalidate_rect, tiling_size(), tiling_rect());
   EXPECT_EQ(gfx::Rect(50, 50, 1, 1).ToString(), invalidate_rect.ToString());
 
-  EXPECT_EQ(1, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(1, pile_->tiling().num_tiles_y());
+  EXPECT_EQ(1, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(1, pile_.tiling().num_tiles_y());
 
   TestPicturePile::PictureInfo& picture_info =
-      pile_->picture_map().find(TestPicturePile::PictureMapKey(0, 0))->second;
+      pile_.picture_map().find(TestPicturePile::PictureMapKey(0, 0))->second;
   // We should have a picture.
   EXPECT_TRUE(!!picture_info.GetPicture());
   gfx::Rect picture_rect = gfx::ScaleToEnclosedRect(
@@ -203,17 +201,17 @@ TEST_F(PicturePileTest, LargeInvalidateInflated) {
   UpdateAndExpandInvalidation(&invalidate_rect, tiling_size(), tiling_rect());
   EXPECT_EQ(gfx::Rect(50, 50, 100, 100).ToString(), invalidate_rect.ToString());
 
-  EXPECT_EQ(1, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(1, pile_->tiling().num_tiles_y());
+  EXPECT_EQ(1, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(1, pile_.tiling().num_tiles_y());
 
   TestPicturePile::PictureInfo& picture_info =
-      pile_->picture_map().find(TestPicturePile::PictureMapKey(0, 0))->second;
+      pile_.picture_map().find(TestPicturePile::PictureMapKey(0, 0))->second;
   EXPECT_TRUE(!!picture_info.GetPicture());
 
-  int expected_inflation = pile_->buffer_pixels();
+  int expected_inflation = pile_.buffer_pixels();
 
   const Picture* base_picture = picture_info.GetPicture();
-  gfx::Rect base_picture_rect(pile_->tiling_size());
+  gfx::Rect base_picture_rect(pile_.tiling_size());
   base_picture_rect.Inset(-expected_inflation, -expected_inflation);
   EXPECT_EQ(base_picture_rect.ToString(),
             base_picture->LayerRect().ToString());
@@ -221,17 +219,17 @@ TEST_F(PicturePileTest, LargeInvalidateInflated) {
 
 TEST_F(PicturePileTest, InvalidateOnTileBoundaryInflated) {
   gfx::Size new_tiling_size =
-      gfx::ToCeiledSize(gfx::ScaleSize(pile_->tiling_size(), 2.f));
+      gfx::ToCeiledSize(gfx::ScaleSize(pile_.tiling_size(), 2.f));
   // This creates initial pictures.
   SetTilingSize(new_tiling_size);
 
   // Due to border pixels, we should have 3 tiles.
-  EXPECT_EQ(3, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(3, pile_->tiling().num_tiles_y());
+  EXPECT_EQ(3, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(3, pile_.tiling().num_tiles_y());
 
   // We should have 1/.125 - 1 = 7 border pixels.
-  EXPECT_EQ(7, pile_->buffer_pixels());
-  EXPECT_EQ(7, pile_->tiling().border_texels());
+  EXPECT_EQ(7, pile_.buffer_pixels());
+  EXPECT_EQ(7, pile_.tiling().border_texels());
 
   // Invalidate everything to have a non zero invalidation frequency.
   UpdateWholePile();
@@ -239,18 +237,18 @@ TEST_F(PicturePileTest, InvalidateOnTileBoundaryInflated) {
   // Invalidate something just over a tile boundary by a single pixel.
   // This will invalidate the tile (1, 1), as well as 1 row of pixels in (1, 0).
   Region invalidate_rect(
-      gfx::Rect(pile_->tiling().TileBoundsWithBorder(0, 0).right(),
-                pile_->tiling().TileBoundsWithBorder(0, 0).bottom() - 1,
+      gfx::Rect(pile_.tiling().TileBoundsWithBorder(0, 0).right(),
+                pile_.tiling().TileBoundsWithBorder(0, 0).bottom() - 1,
                 50,
                 50));
   Region expected_invalidation = invalidate_rect;
   UpdateAndExpandInvalidation(&invalidate_rect, tiling_size(), tiling_rect());
   EXPECT_EQ(expected_invalidation.ToString(), invalidate_rect.ToString());
 
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureInfo& picture_info =
-          pile_->picture_map()
+          pile_.picture_map()
               .find(TestPicturePile::PictureMapKey(i, j))
               ->second;
 
@@ -273,7 +271,7 @@ TEST_F(PicturePileTest, InvalidateOnFullLayer) {
   UpdateWholePile();
 
   // Everything was invalidated once so far.
-  for (auto& it : pile_->picture_map()) {
+  for (auto& it : pile_.picture_map()) {
     EXPECT_FLOAT_EQ(
         1.0f / TestPicturePile::PictureInfo::INVALIDATION_FRAMES_TRACKED,
         it.second.GetInvalidationFrequencyForTesting());
@@ -284,7 +282,7 @@ TEST_F(PicturePileTest, InvalidateOnFullLayer) {
   UpdateAndExpandInvalidation(&invalidation, tiling_size(), tiling_rect());
 
   // Everything was invalidated again.
-  for (auto& it : pile_->picture_map()) {
+  for (auto& it : pile_.picture_map()) {
     EXPECT_FLOAT_EQ(
         2.0f / TestPicturePile::PictureInfo::INVALIDATION_FRAMES_TRACKED,
         it.second.GetInvalidationFrequencyForTesting());
@@ -293,7 +291,7 @@ TEST_F(PicturePileTest, InvalidateOnFullLayer) {
 
 TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
   gfx::Size new_tiling_size =
-      gfx::ToCeiledSize(gfx::ScaleSize(pile_->tiling_size(), 4.f));
+      gfx::ToCeiledSize(gfx::ScaleSize(pile_.tiling_size(), 4.f));
   SetTilingSize(new_tiling_size);
 
   gfx::Rect viewport(tiling_size().width(), 1);
@@ -304,10 +302,10 @@ TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
   }
 
   // Make sure we have a high invalidation frequency.
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureInfo& picture_info =
-          pile_->picture_map()
+          pile_.picture_map()
               .find(TestPicturePile::PictureMapKey(i, j))
               ->second;
       EXPECT_FLOAT_EQ(1.0f, picture_info.GetInvalidationFrequencyForTesting())
@@ -320,10 +318,10 @@ TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
   UpdateAndExpandInvalidation(&invalidation, tiling_size(), viewport);
   EXPECT_EQ(tiling_rect().ToString(), invalidation.ToString());
 
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureInfo& picture_info =
-          pile_->picture_map()
+          pile_.picture_map()
               .find(TestPicturePile::PictureMapKey(i, j))
               ->second;
       EXPECT_FLOAT_EQ(1.0f, picture_info.GetInvalidationFrequencyForTesting());
@@ -340,13 +338,13 @@ TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
   // Update a partial tile that doesn't get recorded. We should expand the
   // invalidation to the entire tiles that overlap it.
   Region small_invalidation =
-      gfx::Rect(pile_->tiling().TileBounds(3, 4).x(),
-                pile_->tiling().TileBounds(3, 4).y() + 10,
+      gfx::Rect(pile_.tiling().TileBounds(3, 4).x(),
+                pile_.tiling().TileBounds(3, 4).y() + 10,
                 1,
                 1);
   UpdateAndExpandInvalidation(&small_invalidation, tiling_size(), viewport);
   EXPECT_TRUE(small_invalidation.Contains(gfx::UnionRects(
-      pile_->tiling().TileBounds(2, 4), pile_->tiling().TileBounds(3, 4))))
+      pile_.tiling().TileBounds(2, 4), pile_.tiling().TileBounds(3, 4))))
       << small_invalidation.ToString();
 
   // Now update with no invalidation and full viewport
@@ -355,10 +353,10 @@ TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
       &empty_invalidation, tiling_size(), tiling_rect());
   EXPECT_EQ(Region().ToString(), empty_invalidation.ToString());
 
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureInfo& picture_info =
-          pile_->picture_map()
+          pile_.picture_map()
               .find(TestPicturePile::PictureMapKey(i, j))
               ->second;
       // Expect the invalidation frequency to be less than 1, since we just
@@ -373,15 +371,15 @@ TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
 
 TEST_F(PicturePileTest, ClearingInvalidatesRecordedRect) {
   gfx::Rect rect(0, 0, 5, 5);
-  EXPECT_TRUE(pile_->CanRasterLayerRect(rect));
-  EXPECT_TRUE(pile_->CanRasterSlowTileCheck(rect));
+  EXPECT_TRUE(pile_.CanRasterLayerRect(rect));
+  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(rect));
 
-  pile_->Clear();
+  pile_.Clear();
 
   // Make sure both the cache-aware check (using recorded region) and the normal
   // check are both false after clearing.
-  EXPECT_FALSE(pile_->CanRasterLayerRect(rect));
-  EXPECT_FALSE(pile_->CanRasterSlowTileCheck(rect));
+  EXPECT_FALSE(pile_.CanRasterLayerRect(rect));
+  EXPECT_FALSE(pile_.CanRasterSlowTileCheck(rect));
 }
 
 TEST_F(PicturePileTest, FrequentInvalidationCanRaster) {
@@ -390,26 +388,26 @@ TEST_F(PicturePileTest, FrequentInvalidationCanRaster) {
   // tiles touching it, but is true for adjacent tiles, even if it
   // overlaps on borders (edge case).
   gfx::Size new_tiling_size =
-      gfx::ToCeiledSize(gfx::ScaleSize(pile_->tiling_size(), 4.f));
+      gfx::ToCeiledSize(gfx::ScaleSize(pile_.tiling_size(), 4.f));
   SetTilingSize(new_tiling_size);
 
-  gfx::Rect tile01_borders = pile_->tiling().TileBoundsWithBorder(0, 1);
-  gfx::Rect tile02_borders = pile_->tiling().TileBoundsWithBorder(0, 2);
-  gfx::Rect tile01_noborders = pile_->tiling().TileBounds(0, 1);
-  gfx::Rect tile02_noborders = pile_->tiling().TileBounds(0, 2);
+  gfx::Rect tile01_borders = pile_.tiling().TileBoundsWithBorder(0, 1);
+  gfx::Rect tile02_borders = pile_.tiling().TileBoundsWithBorder(0, 2);
+  gfx::Rect tile01_noborders = pile_.tiling().TileBounds(0, 1);
+  gfx::Rect tile02_noborders = pile_.tiling().TileBounds(0, 2);
 
   // Sanity check these two tiles are overlapping with borders, since this is
   // what the test is trying to repro.
   EXPECT_TRUE(tile01_borders.Intersects(tile02_borders));
   EXPECT_FALSE(tile01_noborders.Intersects(tile02_noborders));
   UpdateWholePile();
-  EXPECT_TRUE(pile_->CanRasterLayerRect(tile01_noborders));
-  EXPECT_TRUE(pile_->CanRasterSlowTileCheck(tile01_noborders));
-  EXPECT_TRUE(pile_->CanRasterLayerRect(tile02_noborders));
-  EXPECT_TRUE(pile_->CanRasterSlowTileCheck(tile02_noborders));
+  EXPECT_TRUE(pile_.CanRasterLayerRect(tile01_noborders));
+  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile01_noborders));
+  EXPECT_TRUE(pile_.CanRasterLayerRect(tile02_noborders));
+  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile02_noborders));
   // Sanity check that an initial paint goes down the fast path of having
   // a valid recorded viewport.
-  EXPECT_TRUE(!pile_->recorded_viewport().IsEmpty());
+  EXPECT_TRUE(!pile_.recorded_viewport().IsEmpty());
 
   // Update the whole layer until the invalidation frequency is high.
   for (int frame = 0; frame < 33; ++frame) {
@@ -423,42 +421,42 @@ TEST_F(PicturePileTest, FrequentInvalidationCanRaster) {
   EXPECT_EQ(tiling_rect().ToString(), invalidation.ToString());
 
   // Sanity check some pictures exist and others don't.
-  EXPECT_TRUE(pile_->picture_map()
+  EXPECT_TRUE(pile_.picture_map()
                   .find(TestPicturePile::PictureMapKey(0, 1))
                   ->second.GetPicture());
-  EXPECT_FALSE(pile_->picture_map()
+  EXPECT_FALSE(pile_.picture_map()
                    .find(TestPicturePile::PictureMapKey(0, 2))
                    ->second.GetPicture());
 
-  EXPECT_TRUE(pile_->CanRasterLayerRect(tile01_noborders));
-  EXPECT_TRUE(pile_->CanRasterSlowTileCheck(tile01_noborders));
-  EXPECT_FALSE(pile_->CanRasterLayerRect(tile02_noborders));
-  EXPECT_FALSE(pile_->CanRasterSlowTileCheck(tile02_noborders));
+  EXPECT_TRUE(pile_.CanRasterLayerRect(tile01_noborders));
+  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile01_noborders));
+  EXPECT_FALSE(pile_.CanRasterLayerRect(tile02_noborders));
+  EXPECT_FALSE(pile_.CanRasterSlowTileCheck(tile02_noborders));
 }
 
 TEST_F(PicturePileTest, NoInvalidationValidViewport) {
   // This test validates that the recorded_viewport cache of full tiles
   // is still valid for some use cases.  If it's not, it's a performance
   // issue because CanRaster checks will go down the slow path.
-  EXPECT_TRUE(!pile_->recorded_viewport().IsEmpty());
+  EXPECT_TRUE(!pile_.recorded_viewport().IsEmpty());
 
   // No invalidation, same viewport.
   Region invalidation;
   UpdateAndExpandInvalidation(&invalidation, tiling_size(), tiling_rect());
-  EXPECT_TRUE(!pile_->recorded_viewport().IsEmpty());
+  EXPECT_TRUE(!pile_.recorded_viewport().IsEmpty());
   EXPECT_EQ(Region().ToString(), invalidation.ToString());
 
   // Partial invalidation, same viewport.
   invalidation = gfx::Rect(0, 0, 1, 1);
   UpdateAndExpandInvalidation(&invalidation, tiling_size(), tiling_rect());
-  EXPECT_TRUE(!pile_->recorded_viewport().IsEmpty());
+  EXPECT_TRUE(!pile_.recorded_viewport().IsEmpty());
   EXPECT_EQ(gfx::Rect(0, 0, 1, 1).ToString(), invalidation.ToString());
 
   // No invalidation, changing viewport.
   invalidation = Region();
   UpdateAndExpandInvalidation(
       &invalidation, tiling_size(), gfx::Rect(5, 5, 5, 5));
-  EXPECT_TRUE(!pile_->recorded_viewport().IsEmpty());
+  EXPECT_TRUE(!pile_.recorded_viewport().IsEmpty());
   EXPECT_EQ(Region().ToString(), invalidation.ToString());
 }
 
@@ -538,15 +536,15 @@ TEST_F(PicturePileTest, InvalidationOutsideRecordingRect) {
   // Invalidation outside the recording rect should expand to the tiles it
   // covers.
   gfx::Rect recorded_over_tiles =
-      pile_->tiling().ExpandRectToTileBounds(pile_->recorded_viewport());
+      pile_.tiling().ExpandRectToTileBounds(pile_.recorded_viewport());
   gfx::Rect invalidation_outside(
       recorded_over_tiles.right(), recorded_over_tiles.y(), 30, 30);
   invalidation = invalidation_outside;
   UpdateAndExpandInvalidation(&invalidation, huge_layer_size, viewport);
   gfx::Rect expanded_recorded_viewport =
-      pile_->tiling().ExpandRectToTileBounds(pile_->recorded_viewport());
+      pile_.tiling().ExpandRectToTileBounds(pile_.recorded_viewport());
   Region expected_invalidation =
-      pile_->tiling().ExpandRectToTileBounds(invalidation_outside);
+      pile_.tiling().ExpandRectToTileBounds(invalidation_outside);
   EXPECT_EQ(expected_invalidation.ToString(), invalidation.ToString());
 }
 
@@ -598,16 +596,16 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
   Region invalidation;
   Region expected_invalidation;
 
-  pile_->tiling().SetMaxTextureSize(gfx::Size(tile_size, tile_size));
+  pile_.tiling().SetMaxTextureSize(gfx::Size(tile_size, tile_size));
   SetTilingSize(base_tiling_size);
 
   // We should have a recording for every tile.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -619,12 +617,12 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
       CornerSinglePixelRect(corner, grow_down_tiling_size));
 
   // We should have lost the recordings in the bottom row.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(8, pile_->tiling().num_tiles_y());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(8, pile_.tiling().num_tiles_y());
   for (int i = 0; i < 6; ++i) {
     for (int j = 0; j < 6; ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_EQ(j < 5, it != map.end() && it->second.GetPicture());
     }
@@ -634,8 +632,8 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
   expected_invalidation = SubtractRegions(gfx::Rect(grow_down_tiling_size),
                                           gfx::Rect(base_tiling_size));
   // But the new pixels don't cover the whole bottom row.
-  gfx::Rect bottom_row = gfx::UnionRects(pile_->tiling().TileBounds(0, 5),
-                                         pile_->tiling().TileBounds(5, 5));
+  gfx::Rect bottom_row = gfx::UnionRects(pile_.tiling().TileBounds(0, 5),
+                                         pile_.tiling().TileBounds(5, 5));
   EXPECT_FALSE(expected_invalidation.Contains(bottom_row));
   // We invalidated the entire old bottom row.
   expected_invalidation.Union(bottom_row);
@@ -648,12 +646,12 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
                               CornerSinglePixelRect(corner, base_tiling_size));
 
   // We should have lost the recordings that are now outside the tiling only.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_EQ(j < 6, it != map.end() && it->second.GetPicture());
     }
@@ -671,12 +669,12 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
       CornerSinglePixelRect(corner, grow_right_tiling_size));
 
   // We should have lost the recordings in the right column.
-  EXPECT_EQ(8, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
+  EXPECT_EQ(8, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
   for (int i = 0; i < 6; ++i) {
     for (int j = 0; j < 6; ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_EQ(i < 5, it != map.end() && it->second.GetPicture());
     }
@@ -686,8 +684,8 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
   expected_invalidation = SubtractRegions(gfx::Rect(grow_right_tiling_size),
                                           gfx::Rect(base_tiling_size));
   // But the new pixels don't cover the whole right_column.
-  gfx::Rect right_column = gfx::UnionRects(pile_->tiling().TileBounds(5, 0),
-                                           pile_->tiling().TileBounds(5, 5));
+  gfx::Rect right_column = gfx::UnionRects(pile_.tiling().TileBounds(5, 0),
+                                           pile_.tiling().TileBounds(5, 5));
   EXPECT_FALSE(expected_invalidation.Contains(right_column));
   // We invalidated the entire old right column.
   expected_invalidation.Union(right_column);
@@ -700,12 +698,12 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
                               CornerSinglePixelRect(corner, base_tiling_size));
 
   // We should have lost the recordings that are now outside the tiling only.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_EQ(i < 6, it != map.end() && it->second.GetPicture());
     }
@@ -723,12 +721,12 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
       CornerSinglePixelRect(corner, grow_both_tiling_size));
 
   // We should have lost the recordings in the right column and bottom row.
-  EXPECT_EQ(8, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(8, pile_->tiling().num_tiles_y());
+  EXPECT_EQ(8, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(8, pile_.tiling().num_tiles_y());
   for (int i = 0; i < 6; ++i) {
     for (int j = 0; j < 6; ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_EQ(i < 5 && j < 5, it != map.end() && it->second.GetPicture());
     }
@@ -739,10 +737,10 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
                                           gfx::Rect(base_tiling_size));
   // But the new pixels don't cover the whole right_column.
   Region right_column_and_bottom_row =
-      UnionRegions(gfx::UnionRects(pile_->tiling().TileBounds(5, 0),
-                                   pile_->tiling().TileBounds(5, 5)),
-                   gfx::UnionRects(pile_->tiling().TileBounds(0, 5),
-                                   pile_->tiling().TileBounds(5, 5)));
+      UnionRegions(gfx::UnionRects(pile_.tiling().TileBounds(5, 0),
+                                   pile_.tiling().TileBounds(5, 5)),
+                   gfx::UnionRects(pile_.tiling().TileBounds(0, 5),
+                                   pile_.tiling().TileBounds(5, 5)));
   EXPECT_FALSE(expected_invalidation.Contains(right_column_and_bottom_row));
   // We invalidated the entire old right column and the old bottom row.
   expected_invalidation.Union(right_column_and_bottom_row);
@@ -753,12 +751,12 @@ TEST_P(PicturePileResizeCornerTest, ResizePileOutsideInterestRect) {
   UpdateAndExpandInvalidation(&invalidation, base_tiling_size, gfx::Rect());
 
   // We should have lost the recordings that are now outside the tiling only.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_EQ(i < 6 && j < 6, it != map.end() && it->second.GetPicture());
     }
@@ -790,16 +788,16 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
   Region invalidation;
   Region expected_invalidation;
 
-  pile_->tiling().SetMaxTextureSize(gfx::Size(tile_size, tile_size));
+  pile_.tiling().SetMaxTextureSize(gfx::Size(tile_size, tile_size));
   SetTilingSize(base_tiling_size);
 
   // We should have a recording for every tile.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -812,12 +810,12 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
 
   // We should have lost the recordings in the bottom row that do not intersect
   // the interest rect.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       bool expect_tile;
       switch (corner) {
@@ -843,20 +841,20 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
   switch (corner) {
     case TOP_LEFT:
     case TOP_RIGHT:
-      expected_invalidation = gfx::UnionRects(pile_->tiling().TileBounds(0, 5),
-                                              pile_->tiling().TileBounds(5, 5));
+      expected_invalidation = gfx::UnionRects(pile_.tiling().TileBounds(0, 5),
+                                              pile_.tiling().TileBounds(5, 5));
       break;
     case BOTTOM_LEFT:
-      expected_invalidation = gfx::UnionRects(pile_->tiling().TileBounds(1, 5),
-                                              pile_->tiling().TileBounds(5, 5));
-      expected_invalidation.Union(SubtractRects(
-          pile_->tiling().TileBounds(0, 5), gfx::Rect(base_tiling_size)));
+      expected_invalidation = gfx::UnionRects(pile_.tiling().TileBounds(1, 5),
+                                              pile_.tiling().TileBounds(5, 5));
+      expected_invalidation.Union(SubtractRects(pile_.tiling().TileBounds(0, 5),
+                                                gfx::Rect(base_tiling_size)));
       break;
     case BOTTOM_RIGHT:
-      expected_invalidation = gfx::UnionRects(pile_->tiling().TileBounds(0, 5),
-                                              pile_->tiling().TileBounds(4, 5));
-      expected_invalidation.Union(SubtractRects(
-          pile_->tiling().TileBounds(5, 5), gfx::Rect(base_tiling_size)));
+      expected_invalidation = gfx::UnionRects(pile_.tiling().TileBounds(0, 5),
+                                              pile_.tiling().TileBounds(4, 5));
+      expected_invalidation.Union(SubtractRects(pile_.tiling().TileBounds(5, 5),
+                                                gfx::Rect(base_tiling_size)));
       break;
   }
   EXPECT_EQ(expected_invalidation.ToString(), invalidation.ToString());
@@ -868,12 +866,12 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
                               CornerSinglePixelRect(corner, base_tiling_size));
 
   // We should have lost nothing.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -891,12 +889,12 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
       CornerSinglePixelRect(corner, grow_right_tiling_size));
 
   // We should have lost the recordings in the right column.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       bool expect_tile;
       switch (corner) {
@@ -922,20 +920,20 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
   switch (corner) {
     case TOP_LEFT:
     case BOTTOM_LEFT:
-      expected_invalidation = gfx::UnionRects(pile_->tiling().TileBounds(5, 0),
-                                              pile_->tiling().TileBounds(5, 5));
+      expected_invalidation = gfx::UnionRects(pile_.tiling().TileBounds(5, 0),
+                                              pile_.tiling().TileBounds(5, 5));
       break;
     case TOP_RIGHT:
-      expected_invalidation = gfx::UnionRects(pile_->tiling().TileBounds(5, 1),
-                                              pile_->tiling().TileBounds(5, 5));
-      expected_invalidation.Union(SubtractRects(
-          pile_->tiling().TileBounds(5, 0), gfx::Rect(base_tiling_size)));
+      expected_invalidation = gfx::UnionRects(pile_.tiling().TileBounds(5, 1),
+                                              pile_.tiling().TileBounds(5, 5));
+      expected_invalidation.Union(SubtractRects(pile_.tiling().TileBounds(5, 0),
+                                                gfx::Rect(base_tiling_size)));
       break;
     case BOTTOM_RIGHT:
-      expected_invalidation = gfx::UnionRects(pile_->tiling().TileBounds(5, 0),
-                                              pile_->tiling().TileBounds(5, 4));
-      expected_invalidation.Union(SubtractRects(
-          pile_->tiling().TileBounds(5, 5), gfx::Rect(base_tiling_size)));
+      expected_invalidation = gfx::UnionRects(pile_.tiling().TileBounds(5, 0),
+                                              pile_.tiling().TileBounds(5, 4));
+      expected_invalidation.Union(SubtractRects(pile_.tiling().TileBounds(5, 5),
+                                                gfx::Rect(base_tiling_size)));
       break;
   }
   EXPECT_EQ(expected_invalidation.ToString(), invalidation.ToString());
@@ -947,12 +945,12 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
                               CornerSinglePixelRect(corner, base_tiling_size));
 
   // We should have lost nothing.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -971,12 +969,12 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
 
   // We should have lost the recordings in the right column and bottom row. The
   // tile that insects the interest rect in invalidated only on its new pixels.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       bool expect_tile;
       switch (corner) {
@@ -1006,34 +1004,34 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
   // new pixels.
   switch (corner) {
     case TOP_LEFT:
-      expected_invalidation = gfx::UnionRects(pile_->tiling().TileBounds(5, 0),
-                                              pile_->tiling().TileBounds(5, 5));
+      expected_invalidation = gfx::UnionRects(pile_.tiling().TileBounds(5, 0),
+                                              pile_.tiling().TileBounds(5, 5));
       expected_invalidation.Union(gfx::UnionRects(
-          pile_->tiling().TileBounds(0, 5), pile_->tiling().TileBounds(5, 5)));
+          pile_.tiling().TileBounds(0, 5), pile_.tiling().TileBounds(5, 5)));
       break;
     case TOP_RIGHT:
-      expected_invalidation = gfx::UnionRects(pile_->tiling().TileBounds(5, 1),
-                                              pile_->tiling().TileBounds(5, 5));
+      expected_invalidation = gfx::UnionRects(pile_.tiling().TileBounds(5, 1),
+                                              pile_.tiling().TileBounds(5, 5));
       expected_invalidation.Union(gfx::UnionRects(
-          pile_->tiling().TileBounds(0, 5), pile_->tiling().TileBounds(5, 5)));
-      expected_invalidation.Union(SubtractRects(
-          pile_->tiling().TileBounds(5, 0), gfx::Rect(base_tiling_size)));
+          pile_.tiling().TileBounds(0, 5), pile_.tiling().TileBounds(5, 5)));
+      expected_invalidation.Union(SubtractRects(pile_.tiling().TileBounds(5, 0),
+                                                gfx::Rect(base_tiling_size)));
       break;
     case BOTTOM_LEFT:
-      expected_invalidation = gfx::UnionRects(pile_->tiling().TileBounds(5, 0),
-                                              pile_->tiling().TileBounds(5, 5));
+      expected_invalidation = gfx::UnionRects(pile_.tiling().TileBounds(5, 0),
+                                              pile_.tiling().TileBounds(5, 5));
       expected_invalidation.Union(gfx::UnionRects(
-          pile_->tiling().TileBounds(1, 5), pile_->tiling().TileBounds(5, 5)));
-      expected_invalidation.Union(SubtractRects(
-          pile_->tiling().TileBounds(0, 5), gfx::Rect(base_tiling_size)));
+          pile_.tiling().TileBounds(1, 5), pile_.tiling().TileBounds(5, 5)));
+      expected_invalidation.Union(SubtractRects(pile_.tiling().TileBounds(0, 5),
+                                                gfx::Rect(base_tiling_size)));
       break;
     case BOTTOM_RIGHT:
-      expected_invalidation = gfx::UnionRects(pile_->tiling().TileBounds(5, 0),
-                                              pile_->tiling().TileBounds(5, 4));
+      expected_invalidation = gfx::UnionRects(pile_.tiling().TileBounds(5, 0),
+                                              pile_.tiling().TileBounds(5, 4));
       expected_invalidation.Union(gfx::UnionRects(
-          pile_->tiling().TileBounds(0, 5), pile_->tiling().TileBounds(4, 5)));
+          pile_.tiling().TileBounds(0, 5), pile_.tiling().TileBounds(4, 5)));
       expected_invalidation.Union(SubtractRegions(
-          pile_->tiling().TileBounds(5, 5), gfx::Rect(base_tiling_size)));
+          pile_.tiling().TileBounds(5, 5), gfx::Rect(base_tiling_size)));
       break;
   }
   EXPECT_EQ(expected_invalidation.ToString(), invalidation.ToString());
@@ -1045,12 +1043,12 @@ TEST_P(PicturePileResizeCornerTest, SmallResizePileOutsideInterestRect) {
                               CornerSinglePixelRect(corner, base_tiling_size));
 
   // We should have lost nothing.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1080,16 +1078,16 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
   Region invalidation;
   Region expected_invalidation;
 
-  pile_->tiling().SetMaxTextureSize(gfx::Size(tile_size, tile_size));
+  pile_.tiling().SetMaxTextureSize(gfx::Size(tile_size, tile_size));
   SetTilingSize(base_tiling_size);
 
   // We should have a recording for every tile.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1099,12 +1097,12 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
       &invalidation, grow_down_tiling_size, gfx::Rect(1, 1));
 
   // We should have a recording for every tile.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(8, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(8, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1114,8 +1112,8 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
   expected_invalidation = SubtractRegions(gfx::Rect(grow_down_tiling_size),
                                           gfx::Rect(base_tiling_size));
   Region bottom_row_new_pixels =
-      SubtractRegions(gfx::UnionRects(pile_->tiling().TileBounds(0, 5),
-                                      pile_->tiling().TileBounds(5, 5)),
+      SubtractRegions(gfx::UnionRects(pile_.tiling().TileBounds(0, 5),
+                                      pile_.tiling().TileBounds(5, 5)),
                       gfx::Rect(base_tiling_size));
   EXPECT_TRUE(expected_invalidation.Contains(bottom_row_new_pixels));
   EXPECT_EQ(expected_invalidation.ToString(), invalidation.ToString());
@@ -1125,12 +1123,12 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
   UpdateAndExpandInvalidation(&invalidation, base_tiling_size, gfx::Rect(1, 1));
 
   // We should have a recording for every tile.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1145,12 +1143,12 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
       &invalidation, grow_right_tiling_size, gfx::Rect(1, 1));
 
   // We should have a recording for every tile.
-  EXPECT_EQ(8, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(8, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1160,8 +1158,8 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
   expected_invalidation = SubtractRegions(gfx::Rect(grow_right_tiling_size),
                                           gfx::Rect(base_tiling_size));
   Region right_column_new_pixels =
-      SubtractRegions(gfx::UnionRects(pile_->tiling().TileBounds(5, 0),
-                                      pile_->tiling().TileBounds(5, 5)),
+      SubtractRegions(gfx::UnionRects(pile_.tiling().TileBounds(5, 0),
+                                      pile_.tiling().TileBounds(5, 5)),
                       gfx::Rect(base_tiling_size));
   EXPECT_TRUE(expected_invalidation.Contains(right_column_new_pixels));
   EXPECT_EQ(expected_invalidation.ToString(), invalidation.ToString());
@@ -1171,12 +1169,12 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
   UpdateAndExpandInvalidation(&invalidation, base_tiling_size, gfx::Rect(1, 1));
 
   // We should have lost the recordings that are now outside the tiling only.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1191,12 +1189,12 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
       &invalidation, grow_both_tiling_size, gfx::Rect(1, 1));
 
   // We should have a recording for every tile.
-  EXPECT_EQ(8, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(8, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(8, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(8, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1207,10 +1205,10 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
   expected_invalidation = SubtractRegions(gfx::Rect(grow_both_tiling_size),
                                           gfx::Rect(base_tiling_size));
   Region bottom_row_and_right_column_new_pixels = SubtractRegions(
-      UnionRegions(gfx::UnionRects(pile_->tiling().TileBounds(0, 5),
-                                   pile_->tiling().TileBounds(5, 5)),
-                   gfx::UnionRects(pile_->tiling().TileBounds(5, 0),
-                                   pile_->tiling().TileBounds(5, 5))),
+      UnionRegions(gfx::UnionRects(pile_.tiling().TileBounds(0, 5),
+                                   pile_.tiling().TileBounds(5, 5)),
+                   gfx::UnionRects(pile_.tiling().TileBounds(5, 0),
+                                   pile_.tiling().TileBounds(5, 5))),
       gfx::Rect(base_tiling_size));
   EXPECT_TRUE(
       expected_invalidation.Contains(bottom_row_and_right_column_new_pixels));
@@ -1221,12 +1219,12 @@ TEST_F(PicturePileTest, ResizePileInsideInterestRect) {
   UpdateAndExpandInvalidation(&invalidation, base_tiling_size, gfx::Rect());
 
   // We should have lost the recordings that are now outside the tiling only.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1250,16 +1248,16 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
   Region invalidation;
   Region expected_invalidation;
 
-  pile_->tiling().SetMaxTextureSize(gfx::Size(tile_size, tile_size));
+  pile_.tiling().SetMaxTextureSize(gfx::Size(tile_size, tile_size));
   SetTilingSize(base_tiling_size);
 
   // We should have a recording for every tile.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1269,12 +1267,12 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
       &invalidation, grow_down_tiling_size, gfx::Rect(1, 1));
 
   // We should have a recording for every tile.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1290,12 +1288,12 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
   UpdateAndExpandInvalidation(&invalidation, base_tiling_size, gfx::Rect(1, 1));
 
   // We should have a recording for every tile.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1310,12 +1308,12 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
       &invalidation, grow_right_tiling_size, gfx::Rect(1, 1));
 
   // We should have a recording for every tile.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1331,12 +1329,12 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
   UpdateAndExpandInvalidation(&invalidation, base_tiling_size, gfx::Rect(1, 1));
 
   // We should have lost the recordings that are now outside the tiling only.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1351,12 +1349,12 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
       &invalidation, grow_both_tiling_size, gfx::Rect(1, 1));
 
   // We should have a recording for every tile.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1372,12 +1370,12 @@ TEST_F(PicturePileTest, SmallResizePileInsideInterestRect) {
   UpdateAndExpandInvalidation(&invalidation, base_tiling_size, gfx::Rect());
 
   // We should have lost the recordings that are now outside the tiling only.
-  EXPECT_EQ(6, pile_->tiling().num_tiles_x());
-  EXPECT_EQ(6, pile_->tiling().num_tiles_y());
-  for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
-    for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
+  EXPECT_EQ(6, pile_.tiling().num_tiles_x());
+  EXPECT_EQ(6, pile_.tiling().num_tiles_y());
+  for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
+    for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       TestPicturePile::PictureMapKey key(i, j);
-      TestPicturePile::PictureMap& map = pile_->picture_map();
+      TestPicturePile::PictureMap& map = pile_.picture_map();
       TestPicturePile::PictureMap::iterator it = map.find(key);
       EXPECT_TRUE(it != map.end() && it->second.GetPicture());
     }
@@ -1392,8 +1390,8 @@ TEST_F(PicturePileTest, SolidRectangleIsSolid) {
   // If the client has no contents, the solid state will be true.
   Region invalidation1(tiling_rect());
   UpdateAndExpandInvalidation(&invalidation1, tiling_size(), tiling_rect());
-  EXPECT_TRUE(pile_->is_solid_color());
-  EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT), pile_->solid_color());
+  EXPECT_TRUE(pile_.is_solid_color());
+  EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT), pile_.solid_color());
 
   // If there is a single rect that covers the view, the solid
   // state will be true.
@@ -1402,8 +1400,8 @@ TEST_F(PicturePileTest, SolidRectangleIsSolid) {
   client_.add_draw_rect(tiling_rect(), paint);
   Region invalidation2(tiling_rect());
   UpdateAndExpandInvalidation(&invalidation2, tiling_size(), tiling_rect());
-  EXPECT_TRUE(pile_->is_solid_color());
-  EXPECT_EQ(SK_ColorCYAN, pile_->solid_color());
+  EXPECT_TRUE(pile_.is_solid_color());
+  EXPECT_EQ(SK_ColorCYAN, pile_.solid_color());
 
   // If a second smaller rect is draw that doesn't cover the viewport
   // completely, the solid state will be false.
@@ -1412,15 +1410,15 @@ TEST_F(PicturePileTest, SolidRectangleIsSolid) {
   client_.add_draw_rect(smallRect, paint);
   Region invalidation3(tiling_rect());
   UpdateAndExpandInvalidation(&invalidation3, tiling_size(), tiling_rect());
-  EXPECT_FALSE(pile_->is_solid_color());
+  EXPECT_FALSE(pile_.is_solid_color());
 
   // If a third rect is drawn over everything, we should be solid again.
   paint.setColor(SK_ColorRED);
   client_.add_draw_rect(tiling_rect(), paint);
   Region invalidation4(tiling_rect());
   UpdateAndExpandInvalidation(&invalidation4, tiling_size(), tiling_rect());
-  EXPECT_TRUE(pile_->is_solid_color());
-  EXPECT_EQ(SK_ColorRED, pile_->solid_color());
+  EXPECT_TRUE(pile_.is_solid_color());
+  EXPECT_EQ(SK_ColorRED, pile_.solid_color());
 
   // If we draw too many, we don't bother doing the analysis and we should no
   // longer be in a solid state.  There are 8 rects, two clips and a translate.
@@ -1431,7 +1429,7 @@ TEST_F(PicturePileTest, SolidRectangleIsSolid) {
   client_.add_draw_rect(tiling_rect(), paint);
   Region invalidation5(tiling_rect());
   UpdateAndExpandInvalidation(&invalidation5, tiling_size(), tiling_rect());
-  EXPECT_FALSE(pile_->is_solid_color());
+  EXPECT_FALSE(pile_.is_solid_color());
 }
 
 }  // namespace
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.cc b/cc/resources/pixel_buffer_raster_worker_pool.cc
index 9ad641a..3409655 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.cc
+++ b/cc/resources/pixel_buffer_raster_worker_pool.cc
@@ -35,7 +35,7 @@ class RasterBufferImpl : public RasterBuffer {
   }
 
   // Overridden from RasterBuffer:
-  void Playback(const PicturePileImpl* picture_pile,
+  void Playback(const RasterSource* raster_source,
                 const gfx::Rect& rect,
                 float scale,
                 RenderingStatsInstrumentation* stats) override {
@@ -46,7 +46,7 @@ class RasterBufferImpl : public RasterBuffer {
                                        resource_->format(),
                                        resource_->size(),
                                        stride_,
-                                       picture_pile,
+                                       raster_source,
                                        rect,
                                        scale,
                                        stats);
diff --git a/cc/resources/raster_buffer.h b/cc/resources/raster_buffer.h
index df7ea5f..d9791e9 100644
--- a/cc/resources/raster_buffer.h
+++ b/cc/resources/raster_buffer.h
@@ -9,7 +9,7 @@
 #include "ui/gfx/geometry/rect.h"
 
 namespace cc {
-class PicturePileImpl;
+class RasterSource;
 class RenderingStatsInstrumentation;
 
 class CC_EXPORT RasterBuffer {
@@ -17,7 +17,7 @@ class CC_EXPORT RasterBuffer {
   RasterBuffer();
   virtual ~RasterBuffer();
 
-  virtual void Playback(const PicturePileImpl* picture_pile,
+  virtual void Playback(const RasterSource* raster_source,
                         const gfx::Rect& rect,
                         float scale,
                         RenderingStatsInstrumentation* stats) = 0;
diff --git a/cc/resources/raster_source.h b/cc/resources/raster_source.h
new file mode 100644
index 0000000..603b883
--- /dev/null
+++ b/cc/resources/raster_source.h
@@ -0,0 +1,77 @@
+// Copyright 2014 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.
+
+#ifndef CC_RESOURCES_RASTER_SOURCE_H_
+#define CC_RESOURCES_RASTER_SOURCE_H_
+
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "cc/base/cc_export.h"
+#include "third_party/skia/include/core/SkColor.h"
+
+class SkCanvas;
+
+namespace cc {
+
+class RenderingStatsInstrumentation;
+
+class CC_EXPORT RasterSource : public base::RefCountedThreadSafe<RasterSource> {
+ public:
+  struct CC_EXPORT SolidColorAnalysis {
+    SolidColorAnalysis()
+        : is_solid_color(false), solid_color(SK_ColorTRANSPARENT) {}
+    ~SolidColorAnalysis() {}
+
+    bool is_solid_color;
+    SkColor solid_color;
+  };
+
+  // Raster a subrect of this RasterSource into the given canvas. It is
+  // assumed that contents_scale has already been applied to this canvas.
+  // Writes the total number of pixels rasterized and the time spent
+  // rasterizing to the stats if the respective pointer is not nullptr.
+  // TODO(vmpstr): Remove RenderingStatsInstrumentation from the interface.
+  virtual void PlaybackToCanvas(
+      SkCanvas* canvas,
+      const gfx::Rect& canvas_rect,
+      float contents_scale,
+      RenderingStatsInstrumentation* rendering_stats_instrumentation) const = 0;
+
+  // Analyze to determine if the given rect at given scale is of solid color in
+  // this raster source.
+  virtual void PerformSolidColorAnalysis(
+      const gfx::Rect& content_rect,
+      float contents_scale,
+      SolidColorAnalysis* analysis,
+      RenderingStatsInstrumentation* rendering_stats_instrumentation) const = 0;
+
+  // Populate the given list with all SkPixelRefs that may overlap the given
+  // rect at given scale.
+  virtual void GatherPixelRefs(const gfx::Rect& content_rect,
+                               float contents_scale,
+                               std::vector<SkPixelRef*>* pixel_refs) const = 0;
+
+  // Return true iff this raster source can raster the given rect at given
+  // scale.
+  virtual bool CoversRect(const gfx::Rect& content_rect,
+                          float contents_scale) const = 0;
+
+  // Return true iff this raster source would benefit from using distance
+  // field text.
+  virtual bool SuitableForDistanceFieldText() const = 0;
+
+ protected:
+  friend class base::RefCountedThreadSafe<RasterSource>;
+
+  RasterSource() {}
+  virtual ~RasterSource() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RasterSource);
+};
+
+}  // namespace cc
+
+#endif  // CC_RESOURCES_RASTER_SOURCE_H_
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index a52e019..bd91740 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -11,7 +11,8 @@
 #include "base/strings/stringprintf.h"
 #include "base/threading/simple_thread.h"
 #include "cc/base/scoped_ptr_deque.h"
-#include "cc/resources/picture_pile_impl.h"
+#include "cc/resources/raster_source.h"
+#include "third_party/skia/include/core/SkCanvas.h"
 
 namespace cc {
 namespace {
@@ -198,7 +199,7 @@ void RasterWorkerPool::PlaybackToMemory(void* memory,
                                         ResourceFormat format,
                                         const gfx::Size& size,
                                         int stride,
-                                        const PicturePileImpl* picture_pile,
+                                        const RasterSource* raster_source,
                                         const gfx::Rect& rect,
                                         float scale,
                                         RenderingStatsInstrumentation* stats) {
@@ -225,7 +226,7 @@ void RasterWorkerPool::PlaybackToMemory(void* memory,
   }
 
   SkCanvas canvas(bitmap);
-  picture_pile->RasterToBitmap(&canvas, rect, scale, stats);
+  raster_source->PlaybackToCanvas(&canvas, rect, scale, stats);
 
   SkColorType buffer_color_type = ResourceFormatToSkColorType(format);
   if (buffer_color_type != bitmap.colorType()) {
diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/raster_worker_pool.h
index d3c2e35..30d26e5 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -14,7 +14,7 @@ class SequencedTaskRunner;
 }
 
 namespace cc {
-class PicturePileImpl;
+class RasterSource;
 class RenderingStatsInstrumentation;
 
 class CC_EXPORT RasterWorkerPool {
@@ -70,7 +70,7 @@ class CC_EXPORT RasterWorkerPool {
                                ResourceFormat format,
                                const gfx::Size& size,
                                int stride,
-                               const PicturePileImpl* picture_pile,
+                               const RasterSource* raster_source,
                                const gfx::Rect& rect,
                                float scale,
                                RenderingStatsInstrumentation* stats);
diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/raster_worker_pool_unittest.cc
index a6d6c65..c8feb73 100644
--- a/cc/resources/raster_worker_pool_unittest.cc
+++ b/cc/resources/raster_worker_pool_unittest.cc
@@ -46,8 +46,8 @@ enum RasterWorkerPoolType {
 
 class TestRasterTaskImpl : public RasterTask {
  public:
-  typedef base::Callback<
-      void(const PicturePileImpl::Analysis& analysis, bool was_canceled)> Reply;
+  typedef base::Callback<void(const RasterSource::SolidColorAnalysis& analysis,
+                              bool was_canceled)> Reply;
 
   TestRasterTaskImpl(const Resource* resource,
                      const Reply& reply,
@@ -71,7 +71,7 @@ class TestRasterTaskImpl : public RasterTask {
     client->ReleaseBufferForRaster(raster_buffer_.Pass());
   }
   void RunReplyOnOriginThread() override {
-    reply_.Run(PicturePileImpl::Analysis(), !HasFinishedRunning());
+    reply_.Run(RasterSource::SolidColorAnalysis(), !HasFinishedRunning());
   }
 
  protected:
@@ -298,7 +298,7 @@ class RasterWorkerPoolTest
 
   void OnTaskCompleted(scoped_ptr<ScopedResource> resource,
                        unsigned id,
-                       const PicturePileImpl::Analysis& analysis,
+                       const RasterSource::SolidColorAnalysis& analysis,
                        bool was_canceled) {
     RasterTaskResult result;
     result.id = id;
diff --git a/cc/resources/tile.cc b/cc/resources/tile.cc
index e994a5e..d6bd3c4 100644
--- a/cc/resources/tile.cc
+++ b/cc/resources/tile.cc
@@ -17,7 +17,7 @@ namespace cc {
 Tile::Id Tile::s_next_id_ = 0;
 
 Tile::Tile(TileManager* tile_manager,
-           PicturePileImpl* picture_pile,
+           RasterSource* raster_source,
            const gfx::Size& tile_size,
            const gfx::Rect& content_rect,
            float contents_scale,
@@ -37,7 +37,7 @@ Tile::Tile(TileManager* tile_manager,
       tiling_j_index_(-1),
       required_for_activation_(false),
       id_(s_next_id_++) {
-  set_picture_pile(picture_pile);
+  set_raster_source(raster_source);
   for (int i = 0; i < NUM_TREES; i++)
     is_occluded_[i] = false;
 }
@@ -51,7 +51,7 @@ Tile::~Tile() {
 void Tile::AsValueInto(base::debug::TracedValue* res) const {
   TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), res, "cc::Tile", this);
-  TracedValue::SetIDRef(picture_pile_.get(), res, "picture_pile");
+  TracedValue::SetIDRef(raster_source_.get(), res, "picture_pile");
   res->SetDouble("contents_scale", contents_scale_);
 
   res->BeginArray("content_rect");
diff --git a/cc/resources/tile.h b/cc/resources/tile.h
index a712a75..c641367 100644
--- a/cc/resources/tile.h
+++ b/cc/resources/tile.h
@@ -8,7 +8,7 @@
 #include "base/memory/ref_counted.h"
 #include "cc/base/ref_counted_managed.h"
 #include "cc/resources/managed_tile_state.h"
-#include "cc/resources/picture_pile_impl.h"
+#include "cc/resources/raster_source.h"
 #include "cc/resources/tile_priority.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
@@ -25,13 +25,9 @@ class CC_EXPORT Tile : public RefCountedManaged<Tile> {
     return id_;
   }
 
-  PicturePileImpl* picture_pile() {
-    return picture_pile_.get();
-  }
+  RasterSource* raster_source() { return raster_source_.get(); }
 
-  const PicturePileImpl* picture_pile() const {
-    return picture_pile_.get();
-  }
+  const RasterSource* raster_source() const { return raster_source_.get(); }
 
   const TilePriority& priority(WhichTree tree) const {
     return priority_[tree];
@@ -120,12 +116,12 @@ class CC_EXPORT Tile : public RefCountedManaged<Tile> {
 
   int source_frame_number() const { return source_frame_number_; }
 
-  void set_picture_pile(scoped_refptr<PicturePileImpl> pile) {
-    DCHECK(pile->CanRaster(contents_scale_, content_rect_))
+  void set_raster_source(scoped_refptr<RasterSource> raster_source) {
+    DCHECK(raster_source->CoversRect(content_rect_, contents_scale_))
         << "Recording rect: "
         << gfx::ScaleToEnclosingRect(content_rect_, 1.f / contents_scale_)
                .ToString();
-    picture_pile_ = pile;
+    raster_source_ = raster_source;
   }
 
   size_t GPUMemoryUsageInBytes() const;
@@ -148,7 +144,7 @@ class CC_EXPORT Tile : public RefCountedManaged<Tile> {
 
   // Methods called by by tile manager.
   Tile(TileManager* tile_manager,
-       PicturePileImpl* picture_pile,
+       RasterSource* raster_source,
        const gfx::Size& tile_size,
        const gfx::Rect& content_rect,
        float contents_scale,
@@ -163,7 +159,7 @@ class CC_EXPORT Tile : public RefCountedManaged<Tile> {
   bool HasRasterTask() const;
 
   TileManager* tile_manager_;
-  scoped_refptr<PicturePileImpl> picture_pile_;
+  scoped_refptr<RasterSource> raster_source_;
   gfx::Size size_;
   gfx::Rect content_rect_;
   float contents_scale_;
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 77c4df6..86874e7 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -33,7 +33,7 @@ class RasterTaskImpl : public RasterTask {
  public:
   RasterTaskImpl(
       const Resource* resource,
-      PicturePileImpl* picture_pile,
+      RasterSource* raster_source,
       const gfx::Rect& content_rect,
       float contents_scale,
       TileResolution tile_resolution,
@@ -42,10 +42,11 @@ class RasterTaskImpl : public RasterTask {
       int source_frame_number,
       bool analyze_picture,
       RenderingStatsInstrumentation* rendering_stats,
-      const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply,
+      const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>&
+          reply,
       ImageDecodeTask::Vector* dependencies)
       : RasterTask(resource, dependencies),
-        picture_pile_(picture_pile),
+        raster_source_(raster_source),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         tile_resolution_(tile_resolution),
@@ -60,16 +61,16 @@ class RasterTaskImpl : public RasterTask {
   void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread");
 
-    DCHECK(picture_pile_.get());
+    DCHECK(raster_source_.get());
     DCHECK(raster_buffer_);
 
     if (analyze_picture_) {
-      Analyze(picture_pile_.get());
+      Analyze(raster_source_.get());
       if (analysis_.is_solid_color)
         return;
     }
 
-    Raster(picture_pile_.get());
+    Raster(raster_source_.get());
   }
 
   // Overridden from RasterizerTask:
@@ -89,13 +90,13 @@ class RasterTaskImpl : public RasterTask {
   ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }
 
  private:
-  void Analyze(const PicturePileImpl* picture_pile) {
+  void Analyze(const RasterSource* raster_source) {
     frame_viewer_instrumentation::ScopedAnalyzeTask analyze_task(
         tile_id_, tile_resolution_, source_frame_number_, layer_id_);
 
-    DCHECK(picture_pile);
+    DCHECK(raster_source);
 
-    picture_pile->AnalyzeInRect(
+    raster_source->PerformSolidColorAnalysis(
         content_rect_, contents_scale_, &analysis_, rendering_stats_);
 
     // Record the solid color prediction.
@@ -106,7 +107,7 @@ class RasterTaskImpl : public RasterTask {
     analysis_.is_solid_color &= kUseColorEstimator;
   }
 
-  void Raster(const PicturePileImpl* picture_pile) {
+  void Raster(const RasterSource* raster_source) {
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
         tile_id_, tile_resolution_, source_frame_number_, layer_id_);
     devtools_instrumentation::ScopedLayerTask layer_task(
@@ -121,10 +122,10 @@ class RasterTaskImpl : public RasterTask {
     // before we draw and sometimes they aren't)
     RenderingStatsInstrumentation* stats =
         tile_resolution_ == HIGH_RESOLUTION ? rendering_stats_ : NULL;
-    DCHECK(picture_pile);
+    DCHECK(raster_source);
 
     raster_buffer_->Playback(
-        picture_pile_.get(), content_rect_, contents_scale_, stats);
+        raster_source_.get(), content_rect_, contents_scale_, stats);
 
     if (rendering_stats_->record_rendering_stats()) {
       base::TimeDelta current_rasterize_time =
@@ -138,8 +139,8 @@ class RasterTaskImpl : public RasterTask {
     }
   }
 
-  PicturePileImpl::Analysis analysis_;
-  scoped_refptr<PicturePileImpl> picture_pile_;
+  RasterSource::SolidColorAnalysis analysis_;
+  scoped_refptr<RasterSource> raster_source_;
   gfx::Rect content_rect_;
   float contents_scale_;
   TileResolution tile_resolution_;
@@ -148,7 +149,8 @@ class RasterTaskImpl : public RasterTask {
   int source_frame_number_;
   bool analyze_picture_;
   RenderingStatsInstrumentation* rendering_stats_;
-  const base::Callback<void(const PicturePileImpl::Analysis&, bool)> reply_;
+  const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>
+      reply_;
   scoped_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
@@ -733,11 +735,10 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
   // Create and queue all image decode tasks that this tile depends on.
   ImageDecodeTask::Vector decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
-  for (PicturePileImpl::PixelRefIterator iter(
-           tile->content_rect(), tile->contents_scale(), tile->picture_pile());
-       iter;
-       ++iter) {
-    SkPixelRef* pixel_ref = *iter;
+  std::vector<SkPixelRef*> pixel_refs;
+  tile->raster_source()->GatherPixelRefs(
+      tile->content_rect(), tile->contents_scale(), &pixel_refs);
+  for (SkPixelRef* pixel_ref : pixel_refs) {
     uint32_t id = pixel_ref->getGenerationID();
 
     // Append existing image decode task if available.
@@ -756,7 +757,7 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
 
   return make_scoped_refptr(
       new RasterTaskImpl(const_resource,
-                         tile->picture_pile(),
+                         tile->raster_source(),
                          tile->content_rect(),
                          tile->contents_scale(),
                          mts.resolution,
@@ -795,7 +796,7 @@ void TileManager::OnImageDecodeTaskCompleted(int layer_id,
 void TileManager::OnRasterTaskCompleted(
     Tile::Id tile_id,
     scoped_ptr<ScopedResource> resource,
-    const PicturePileImpl::Analysis& analysis,
+    const RasterSource::SolidColorAnalysis& analysis,
     bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
@@ -827,7 +828,7 @@ void TileManager::OnRasterTaskCompleted(
   client_->NotifyTileStateChanged(tile);
 }
 
-scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
+scoped_refptr<Tile> TileManager::CreateTile(RasterSource* raster_source,
                                             const gfx::Size& tile_size,
                                             const gfx::Rect& content_rect,
                                             float contents_scale,
@@ -835,7 +836,7 @@ scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
                                             int source_frame_number,
                                             int flags) {
   scoped_refptr<Tile> tile = make_scoped_refptr(new Tile(this,
-                                                         picture_pile,
+                                                         raster_source,
                                                          tile_size,
                                                          content_rect,
                                                          contents_scale,
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index 6f579f9..f5bea38 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -20,7 +20,7 @@
 #include "cc/resources/eviction_tile_priority_queue.h"
 #include "cc/resources/managed_tile_state.h"
 #include "cc/resources/memory_history.h"
-#include "cc/resources/picture_pile_impl.h"
+#include "cc/resources/raster_source.h"
 #include "cc/resources/raster_tile_priority_queue.h"
 #include "cc/resources/rasterizer.h"
 #include "cc/resources/resource_pool.h"
@@ -107,7 +107,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
   // Returns true when visible tiles have been initialized.
   bool UpdateVisibleTiles();
 
-  scoped_refptr<Tile> CreateTile(PicturePileImpl* picture_pile,
+  scoped_refptr<Tile> CreateTile(RasterSource* raster_source,
                                  const gfx::Size& tile_size,
                                  const gfx::Rect& content_rect,
                                  float contents_scale,
@@ -213,7 +213,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
                                   bool was_canceled);
   void OnRasterTaskCompleted(Tile::Id tile,
                              scoped_ptr<ScopedResource> resource,
-                             const PicturePileImpl::Analysis& analysis,
+                             const RasterSource::SolidColorAnalysis& analysis,
                              bool was_canceled);
 
   void FreeResourcesForTile(Tile* tile);
diff --git a/cc/resources/zero_copy_raster_worker_pool.cc b/cc/resources/zero_copy_raster_worker_pool.cc
index f5c04d3..4030942 100644
--- a/cc/resources/zero_copy_raster_worker_pool.cc
+++ b/cc/resources/zero_copy_raster_worker_pool.cc
@@ -24,7 +24,7 @@ class RasterBufferImpl : public RasterBuffer {
       : lock_(resource_provider, resource->id()), resource_(resource) {}
 
   // Overridden from RasterBuffer:
-  void Playback(const PicturePileImpl* picture_pile,
+  void Playback(const RasterSource* raster_source,
                 const gfx::Rect& rect,
                 float scale,
                 RenderingStatsInstrumentation* stats) override {
@@ -36,7 +36,7 @@ class RasterBufferImpl : public RasterBuffer {
                                        resource_->format(),
                                        resource_->size(),
                                        gpu_memory_buffer->GetStride(),
-                                       picture_pile,
+                                       raster_source,
                                        rect,
                                        scale,
                                        stats);
diff --git a/cc/test/fake_picture_layer_tiling_client.cc b/cc/test/fake_picture_layer_tiling_client.cc
index a0096d1..2149ff4 100644
--- a/cc/test/fake_picture_layer_tiling_client.cc
+++ b/cc/test/fake_picture_layer_tiling_client.cc
@@ -47,7 +47,7 @@ scoped_refptr<Tile> FakePictureLayerTilingClient::CreateTile(
   return tile_manager_->CreateTile(pile_.get(), tile_size_, rect, 1, 0, 0, 0);
 }
 
-PicturePileImpl* FakePictureLayerTilingClient::GetPile() {
+RasterSource* FakePictureLayerTilingClient::GetRasterSource() {
   return pile_.get();
 }
 
diff --git a/cc/test/fake_picture_layer_tiling_client.h b/cc/test/fake_picture_layer_tiling_client.h
index c128990..3df4ca4 100644
--- a/cc/test/fake_picture_layer_tiling_client.h
+++ b/cc/test/fake_picture_layer_tiling_client.h
@@ -23,7 +23,7 @@ class FakePictureLayerTilingClient : public PictureLayerTilingClient {
   // PictureLayerTilingClient implementation.
   scoped_refptr<Tile> CreateTile(PictureLayerTiling* tiling,
                                  const gfx::Rect& rect) override;
-  PicturePileImpl* GetPile() override;
+  RasterSource* GetRasterSource() override;
   gfx::Size CalculateTileSize(const gfx::Size& content_bounds) const override;
   size_t GetMaxTilesForInterestArea() const override;
   float GetSkewportTargetTimeInSeconds() const override;